[flang-commits] [flang] Reduce memory consumption when compiling flang (PR #124919)

[Krzysztof Parzyszek via flang-commits]

https://github.com/kparzysz updated https://github.com/llvm/llvm-project/pull/124919

>From 4d5723165c3565356ceca066dcdc4431f4f2108b Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Wed, 29 Jan 2025 07:08:20 -0600
Subject: [PATCH 1/2] Move all templates from Utils.h to Utils.cpp

---
 flang/include/flang/Lower/Support/Utils.h | 7647 ++++++++++++++++++--
 flang/lib/Lower/CMakeLists.txt            |    1 +
 flang/lib/Lower/Support/Utils.cpp         | 7757 +++++++++++++++++++++
 3 files changed, 15009 insertions(+), 396 deletions(-)
 create mode 100644 flang/lib/Lower/Support/Utils.cpp

diff --git a/flang/include/flang/Lower/Support/Utils.h b/flang/include/flang/Lower/Support/Utils.h
index 1cc74521e22d88..26c1794030017d 100644
--- a/flang/include/flang/Lower/Support/Utils.h
+++ b/flang/include/flang/Lower/Support/Utils.h
@@ -106,247 +106,96 @@ class HashEvaluateExpr {
 public:
   // A Se::Symbol is the only part of an Fortran::evaluate::Expr with an
   // identity property.
-  static unsigned getHashValue(const Fortran::semantics::Symbol &x) {
-    return static_cast<unsigned>(reinterpret_cast<std::intptr_t>(&x));
-  }
+  static unsigned getHashValue(const Fortran::semantics::Symbol &x);
   template <typename A, bool COPY>
-  static unsigned getHashValue(const Fortran::common::Indirection<A, COPY> &x) {
-    return getHashValue(x.value());
-  }
-  template <typename A>
-  static unsigned getHashValue(const std::optional<A> &x) {
-    if (x.has_value())
-      return getHashValue(x.value());
-    return 0u;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::Subscript &x) {
-    return Fortran::common::visit(
-        [&](const auto &v) { return getHashValue(v); }, x.u);
-  }
-  static unsigned getHashValue(const Fortran::evaluate::Triplet &x) {
-    return getHashValue(x.lower()) - getHashValue(x.upper()) * 5u -
-           getHashValue(x.stride()) * 11u;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::Component &x) {
-    return getHashValue(x.base()) * 83u - getHashValue(x.GetLastSymbol());
-  }
-  static unsigned getHashValue(const Fortran::evaluate::ArrayRef &x) {
-    unsigned subs = 1u;
-    for (const Fortran::evaluate::Subscript &v : x.subscript())
-      subs -= getHashValue(v);
-    return getHashValue(x.base()) * 89u - subs;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::CoarrayRef &x) {
-    unsigned subs = 1u;
-    for (const Fortran::evaluate::Subscript &v : x.subscript())
-      subs -= getHashValue(v);
-    unsigned cosubs = 3u;
-    for (const Fortran::evaluate::Expr<Fortran::evaluate::SubscriptInteger> &v :
-         x.cosubscript())
-      cosubs -= getHashValue(v);
-    unsigned syms = 7u;
-    for (const Fortran::evaluate::SymbolRef &v : x.base())
-      syms += getHashValue(v);
-    return syms * 97u - subs - cosubs + getHashValue(x.stat()) + 257u +
-           getHashValue(x.team());
-  }
-  static unsigned getHashValue(const Fortran::evaluate::NamedEntity &x) {
-    if (x.IsSymbol())
-      return getHashValue(x.GetFirstSymbol()) * 11u;
-    return getHashValue(x.GetComponent()) * 13u;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::DataRef &x) {
-    return Fortran::common::visit(
-        [&](const auto &v) { return getHashValue(v); }, x.u);
-  }
-  static unsigned getHashValue(const Fortran::evaluate::ComplexPart &x) {
-    return getHashValue(x.complex()) - static_cast<unsigned>(x.part());
-  }
+  static unsigned getHashValue(const Fortran::common::Indirection<A, COPY> &x);
+  template <typename A> static unsigned getHashValue(const std::optional<A> &x);
+  static unsigned getHashValue(const Fortran::evaluate::Subscript &x);
+  static unsigned getHashValue(const Fortran::evaluate::Triplet &x);
+  static unsigned getHashValue(const Fortran::evaluate::Component &x);
+  static unsigned getHashValue(const Fortran::evaluate::ArrayRef &x);
+  static unsigned getHashValue(const Fortran::evaluate::CoarrayRef &x);
+  static unsigned getHashValue(const Fortran::evaluate::NamedEntity &x);
+  static unsigned getHashValue(const Fortran::evaluate::DataRef &x);
+  static unsigned getHashValue(const Fortran::evaluate::ComplexPart &x);
   template <Fortran::common::TypeCategory TC1, int KIND,
             Fortran::common::TypeCategory TC2>
   static unsigned getHashValue(
       const Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>, TC2>
-          &x) {
-    return getHashValue(x.left()) - (static_cast<unsigned>(TC1) + 2u) -
-           (static_cast<unsigned>(KIND) + 5u);
-  }
+          &x);
   template <int KIND>
   static unsigned
-  getHashValue(const Fortran::evaluate::ComplexComponent<KIND> &x) {
-    return getHashValue(x.left()) -
-           (static_cast<unsigned>(x.isImaginaryPart) + 1u) * 3u;
-  }
+  getHashValue(const Fortran::evaluate::ComplexComponent<KIND> &x);
   template <typename T>
-  static unsigned getHashValue(const Fortran::evaluate::Parentheses<T> &x) {
-    return getHashValue(x.left()) * 17u;
-  }
+  static unsigned getHashValue(const Fortran::evaluate::Parentheses<T> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
-      const Fortran::evaluate::Negate<Fortran::evaluate::Type<TC, KIND>> &x) {
-    return getHashValue(x.left()) - (static_cast<unsigned>(TC) + 5u) -
-           (static_cast<unsigned>(KIND) + 7u);
-  }
+      const Fortran::evaluate::Negate<Fortran::evaluate::Type<TC, KIND>> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
-      const Fortran::evaluate::Add<Fortran::evaluate::Type<TC, KIND>> &x) {
-    return (getHashValue(x.left()) + getHashValue(x.right())) * 23u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
-  }
+      const Fortran::evaluate::Add<Fortran::evaluate::Type<TC, KIND>> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
-      const Fortran::evaluate::Subtract<Fortran::evaluate::Type<TC, KIND>> &x) {
-    return (getHashValue(x.left()) - getHashValue(x.right())) * 19u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
-  }
+      const Fortran::evaluate::Subtract<Fortran::evaluate::Type<TC, KIND>> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
-      const Fortran::evaluate::Multiply<Fortran::evaluate::Type<TC, KIND>> &x) {
-    return (getHashValue(x.left()) + getHashValue(x.right())) * 29u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
-  }
+      const Fortran::evaluate::Multiply<Fortran::evaluate::Type<TC, KIND>> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
-      const Fortran::evaluate::Divide<Fortran::evaluate::Type<TC, KIND>> &x) {
-    return (getHashValue(x.left()) - getHashValue(x.right())) * 31u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
-  }
+      const Fortran::evaluate::Divide<Fortran::evaluate::Type<TC, KIND>> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
-      const Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>> &x) {
-    return (getHashValue(x.left()) - getHashValue(x.right())) * 37u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
-  }
+      const Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
-      const Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>> &x) {
-    return (getHashValue(x.left()) + getHashValue(x.right())) * 41u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND) +
-           static_cast<unsigned>(x.ordering) * 7u;
-  }
+      const Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
       const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>
-          &x) {
-    return (getHashValue(x.left()) - getHashValue(x.right())) * 43u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
-  }
+          &x);
   template <int KIND>
   static unsigned
-  getHashValue(const Fortran::evaluate::ComplexConstructor<KIND> &x) {
-    return (getHashValue(x.left()) - getHashValue(x.right())) * 47u +
-           static_cast<unsigned>(KIND);
-  }
+  getHashValue(const Fortran::evaluate::ComplexConstructor<KIND> &x);
   template <int KIND>
-  static unsigned getHashValue(const Fortran::evaluate::Concat<KIND> &x) {
-    return (getHashValue(x.left()) - getHashValue(x.right())) * 53u +
-           static_cast<unsigned>(KIND);
-  }
+  static unsigned getHashValue(const Fortran::evaluate::Concat<KIND> &x);
   template <int KIND>
-  static unsigned getHashValue(const Fortran::evaluate::SetLength<KIND> &x) {
-    return (getHashValue(x.left()) - getHashValue(x.right())) * 59u +
-           static_cast<unsigned>(KIND);
-  }
-  static unsigned getHashValue(const Fortran::semantics::SymbolRef &sym) {
-    return getHashValue(sym.get());
-  }
-  static unsigned getHashValue(const Fortran::evaluate::Substring &x) {
-    return 61u *
-               Fortran::common::visit(
-                   [&](const auto &p) { return getHashValue(p); }, x.parent()) -
-           getHashValue(x.lower()) - (getHashValue(x.lower()) + 1u);
-  }
+  static unsigned getHashValue(const Fortran::evaluate::SetLength<KIND> &x);
+  static unsigned getHashValue(const Fortran::semantics::SymbolRef &sym);
+  static unsigned getHashValue(const Fortran::evaluate::Substring &x);
   static unsigned
-  getHashValue(const Fortran::evaluate::StaticDataObject::Pointer &x) {
-    return llvm::hash_value(x->name());
-  }
-  static unsigned getHashValue(const Fortran::evaluate::SpecificIntrinsic &x) {
-    return llvm::hash_value(x.name);
-  }
+  getHashValue(const Fortran::evaluate::StaticDataObject::Pointer &x);
+  static unsigned getHashValue(const Fortran::evaluate::SpecificIntrinsic &x);
   template <typename A>
-  static unsigned getHashValue(const Fortran::evaluate::Constant<A> &x) {
-    // FIXME: Should hash the content.
-    return 103u;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::ActualArgument &x) {
-    if (const Fortran::evaluate::Symbol *sym = x.GetAssumedTypeDummy())
-      return getHashValue(*sym);
-    return getHashValue(*x.UnwrapExpr());
-  }
-  static unsigned
-  getHashValue(const Fortran::evaluate::ProcedureDesignator &x) {
-    return Fortran::common::visit(
-        [&](const auto &v) { return getHashValue(v); }, x.u);
-  }
-  static unsigned getHashValue(const Fortran::evaluate::ProcedureRef &x) {
-    unsigned args = 13u;
-    for (const std::optional<Fortran::evaluate::ActualArgument> &v :
-         x.arguments())
-      args -= getHashValue(v);
-    return getHashValue(x.proc()) * 101u - args;
-  }
+  static unsigned getHashValue(const Fortran::evaluate::Constant<A> &x);
+  static unsigned getHashValue(const Fortran::evaluate::ActualArgument &x);
+  static unsigned getHashValue(const Fortran::evaluate::ProcedureDesignator &x);
+  static unsigned getHashValue(const Fortran::evaluate::ProcedureRef &x);
   template <typename A>
+  static unsigned getHashValue(const Fortran::evaluate::ArrayConstructor<A> &x);
+  static unsigned getHashValue(const Fortran::evaluate::ImpliedDoIndex &x);
+  static unsigned getHashValue(const Fortran::evaluate::TypeParamInquiry &x);
+  static unsigned getHashValue(const Fortran::evaluate::DescriptorInquiry &x);
   static unsigned
-  getHashValue(const Fortran::evaluate::ArrayConstructor<A> &x) {
-    // FIXME: hash the contents.
-    return 127u;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::ImpliedDoIndex &x) {
-    return llvm::hash_value(toStringRef(x.name).str()) * 131u;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::TypeParamInquiry &x) {
-    return getHashValue(x.base()) * 137u - getHashValue(x.parameter()) * 3u;
-  }
-  static unsigned getHashValue(const Fortran::evaluate::DescriptorInquiry &x) {
-    return getHashValue(x.base()) * 139u -
-           static_cast<unsigned>(x.field()) * 13u +
-           static_cast<unsigned>(x.dimension());
-  }
-  static unsigned
-  getHashValue(const Fortran::evaluate::StructureConstructor &x) {
-    // FIXME: hash the contents.
-    return 149u;
-  }
+  getHashValue(const Fortran::evaluate::StructureConstructor &x);
   template <int KIND>
-  static unsigned getHashValue(const Fortran::evaluate::Not<KIND> &x) {
-    return getHashValue(x.left()) * 61u + static_cast<unsigned>(KIND);
-  }
+  static unsigned getHashValue(const Fortran::evaluate::Not<KIND> &x);
   template <int KIND>
   static unsigned
-  getHashValue(const Fortran::evaluate::LogicalOperation<KIND> &x) {
-    unsigned result = getHashValue(x.left()) + getHashValue(x.right());
-    return result * 67u + static_cast<unsigned>(x.logicalOperator) * 5u;
-  }
+  getHashValue(const Fortran::evaluate::LogicalOperation<KIND> &x);
   template <Fortran::common::TypeCategory TC, int KIND>
   static unsigned getHashValue(
       const Fortran::evaluate::Relational<Fortran::evaluate::Type<TC, KIND>>
-          &x) {
-    return (getHashValue(x.left()) + getHashValue(x.right())) * 71u +
-           static_cast<unsigned>(TC) + static_cast<unsigned>(KIND) +
-           static_cast<unsigned>(x.opr) * 11u;
-  }
+          &x);
   template <typename A>
-  static unsigned getHashValue(const Fortran::evaluate::Expr<A> &x) {
-    return Fortran::common::visit(
-        [&](const auto &v) { return getHashValue(v); }, x.u);
-  }
+  static unsigned getHashValue(const Fortran::evaluate::Expr<A> &x);
   static unsigned getHashValue(
-      const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &x) {
-    return Fortran::common::visit(
-        [&](const auto &v) { return getHashValue(v); }, x.u);
-  }
+      const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &x);
   template <typename A>
-  static unsigned getHashValue(const Fortran::evaluate::Designator<A> &x) {
-    return Fortran::common::visit(
-        [&](const auto &v) { return getHashValue(v); }, x.u);
-  }
+  static unsigned getHashValue(const Fortran::evaluate::Designator<A> &x);
   template <int BITS>
   static unsigned
-  getHashValue(const Fortran::evaluate::value::Integer<BITS> &x) {
-    return static_cast<unsigned>(x.ToSInt());
-  }
-  static unsigned getHashValue(const Fortran::evaluate::NullPointer &x) {
-    return ~179u;
-  }
+  getHashValue(const Fortran::evaluate::value::Integer<BITS> &x);
+  static unsigned getHashValue(const Fortran::evaluate::NullPointer &x);
 };
 
 // Define the is equals test for using Fortran::evaluate::Expr values with
@@ -356,278 +205,129 @@ class IsEqualEvaluateExpr {
   // A Se::Symbol is the only part of an Fortran::evaluate::Expr with an
   // identity property.
   static bool isEqual(const Fortran::semantics::Symbol &x,
-                      const Fortran::semantics::Symbol &y) {
-    return isEqual(&x, &y);
-  }
+                      const Fortran::semantics::Symbol &y);
   static bool isEqual(const Fortran::semantics::Symbol *x,
-                      const Fortran::semantics::Symbol *y) {
-    return x == y;
-  }
+                      const Fortran::semantics::Symbol *y);
   template <typename A, bool COPY>
   static bool isEqual(const Fortran::common::Indirection<A, COPY> &x,
-                      const Fortran::common::Indirection<A, COPY> &y) {
-    return isEqual(x.value(), y.value());
-  }
+                      const Fortran::common::Indirection<A, COPY> &y);
   template <typename A>
-  static bool isEqual(const std::optional<A> &x, const std::optional<A> &y) {
-    if (x.has_value() && y.has_value())
-      return isEqual(x.value(), y.value());
-    return !x.has_value() && !y.has_value();
-  }
+  static bool isEqual(const std::optional<A> &x, const std::optional<A> &y);
   template <typename A>
-  static bool isEqual(const std::vector<A> &x, const std::vector<A> &y) {
-    if (x.size() != y.size())
-      return false;
-    const std::size_t size = x.size();
-    for (std::remove_const_t<decltype(size)> i = 0; i < size; ++i)
-      if (!isEqual(x[i], y[i]))
-        return false;
-    return true;
-  }
+  static bool isEqual(const std::vector<A> &x, const std::vector<A> &y);
   static bool isEqual(const Fortran::evaluate::Subscript &x,
-                      const Fortran::evaluate::Subscript &y) {
-    return Fortran::common::visit(
-        [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
-  }
+                      const Fortran::evaluate::Subscript &y);
   static bool isEqual(const Fortran::evaluate::Triplet &x,
-                      const Fortran::evaluate::Triplet &y) {
-    return isEqual(x.lower(), y.lower()) && isEqual(x.upper(), y.upper()) &&
-           isEqual(x.stride(), y.stride());
-  }
+                      const Fortran::evaluate::Triplet &y);
   static bool isEqual(const Fortran::evaluate::Component &x,
-                      const Fortran::evaluate::Component &y) {
-    return isEqual(x.base(), y.base()) &&
-           isEqual(x.GetLastSymbol(), y.GetLastSymbol());
-  }
+                      const Fortran::evaluate::Component &y);
   static bool isEqual(const Fortran::evaluate::ArrayRef &x,
-                      const Fortran::evaluate::ArrayRef &y) {
-    return isEqual(x.base(), y.base()) && isEqual(x.subscript(), y.subscript());
-  }
+                      const Fortran::evaluate::ArrayRef &y);
   static bool isEqual(const Fortran::evaluate::CoarrayRef &x,
-                      const Fortran::evaluate::CoarrayRef &y) {
-    return isEqual(x.base(), y.base()) &&
-           isEqual(x.subscript(), y.subscript()) &&
-           isEqual(x.cosubscript(), y.cosubscript()) &&
-           isEqual(x.stat(), y.stat()) && isEqual(x.team(), y.team());
-  }
+                      const Fortran::evaluate::CoarrayRef &y);
   static bool isEqual(const Fortran::evaluate::NamedEntity &x,
-                      const Fortran::evaluate::NamedEntity &y) {
-    if (x.IsSymbol() && y.IsSymbol())
-      return isEqual(x.GetFirstSymbol(), y.GetFirstSymbol());
-    return !x.IsSymbol() && !y.IsSymbol() &&
-           isEqual(x.GetComponent(), y.GetComponent());
-  }
+                      const Fortran::evaluate::NamedEntity &y);
   static bool isEqual(const Fortran::evaluate::DataRef &x,
-                      const Fortran::evaluate::DataRef &y) {
-    return Fortran::common::visit(
-        [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
-  }
+                      const Fortran::evaluate::DataRef &y);
   static bool isEqual(const Fortran::evaluate::ComplexPart &x,
-                      const Fortran::evaluate::ComplexPart &y) {
-    return isEqual(x.complex(), y.complex()) && x.part() == y.part();
-  }
+                      const Fortran::evaluate::ComplexPart &y);
   template <typename A, Fortran::common::TypeCategory TC2>
   static bool isEqual(const Fortran::evaluate::Convert<A, TC2> &x,
-                      const Fortran::evaluate::Convert<A, TC2> &y) {
-    return isEqual(x.left(), y.left());
-  }
+                      const Fortran::evaluate::Convert<A, TC2> &y);
   template <int KIND>
   static bool isEqual(const Fortran::evaluate::ComplexComponent<KIND> &x,
-                      const Fortran::evaluate::ComplexComponent<KIND> &y) {
-    return isEqual(x.left(), y.left()) &&
-           x.isImaginaryPart == y.isImaginaryPart;
-  }
+                      const Fortran::evaluate::ComplexComponent<KIND> &y);
   template <typename T>
   static bool isEqual(const Fortran::evaluate::Parentheses<T> &x,
-                      const Fortran::evaluate::Parentheses<T> &y) {
-    return isEqual(x.left(), y.left());
-  }
+                      const Fortran::evaluate::Parentheses<T> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Negate<A> &x,
-                      const Fortran::evaluate::Negate<A> &y) {
-    return isEqual(x.left(), y.left());
-  }
-  template <typename A>
-  static bool isBinaryEqual(const A &x, const A &y) {
-    return isEqual(x.left(), y.left()) && isEqual(x.right(), y.right());
-  }
+                      const Fortran::evaluate::Negate<A> &y);
+  template <typename A> static bool isBinaryEqual(const A &x, const A &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Add<A> &x,
-                      const Fortran::evaluate::Add<A> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::Add<A> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Subtract<A> &x,
-                      const Fortran::evaluate::Subtract<A> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::Subtract<A> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Multiply<A> &x,
-                      const Fortran::evaluate::Multiply<A> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::Multiply<A> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Divide<A> &x,
-                      const Fortran::evaluate::Divide<A> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::Divide<A> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Power<A> &x,
-                      const Fortran::evaluate::Power<A> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::Power<A> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Extremum<A> &x,
-                      const Fortran::evaluate::Extremum<A> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::Extremum<A> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::RealToIntPower<A> &x,
-                      const Fortran::evaluate::RealToIntPower<A> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::RealToIntPower<A> &y);
   template <int KIND>
   static bool isEqual(const Fortran::evaluate::ComplexConstructor<KIND> &x,
-                      const Fortran::evaluate::ComplexConstructor<KIND> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::ComplexConstructor<KIND> &y);
   template <int KIND>
   static bool isEqual(const Fortran::evaluate::Concat<KIND> &x,
-                      const Fortran::evaluate::Concat<KIND> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::Concat<KIND> &y);
   template <int KIND>
   static bool isEqual(const Fortran::evaluate::SetLength<KIND> &x,
-                      const Fortran::evaluate::SetLength<KIND> &y) {
-    return isBinaryEqual(x, y);
-  }
+                      const Fortran::evaluate::SetLength<KIND> &y);
   static bool isEqual(const Fortran::semantics::SymbolRef &x,
-                      const Fortran::semantics::SymbolRef &y) {
-    return isEqual(x.get(), y.get());
-  }
+                      const Fortran::semantics::SymbolRef &y);
   static bool isEqual(const Fortran::evaluate::Substring &x,
-                      const Fortran::evaluate::Substring &y) {
-    return Fortran::common::visit(
-               [&](const auto &p, const auto &q) { return isEqual(p, q); },
-               x.parent(), y.parent()) &&
-           isEqual(x.lower(), y.lower()) && isEqual(x.upper(), y.upper());
-  }
+                      const Fortran::evaluate::Substring &y);
   static bool isEqual(const Fortran::evaluate::StaticDataObject::Pointer &x,
-                      const Fortran::evaluate::StaticDataObject::Pointer &y) {
-    return x->name() == y->name();
-  }
+                      const Fortran::evaluate::StaticDataObject::Pointer &y);
   static bool isEqual(const Fortran::evaluate::SpecificIntrinsic &x,
-                      const Fortran::evaluate::SpecificIntrinsic &y) {
-    return x.name == y.name;
-  }
+                      const Fortran::evaluate::SpecificIntrinsic &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Constant<A> &x,
-                      const Fortran::evaluate::Constant<A> &y) {
-    return x == y;
-  }
+                      const Fortran::evaluate::Constant<A> &y);
   static bool isEqual(const Fortran::evaluate::ActualArgument &x,
-                      const Fortran::evaluate::ActualArgument &y) {
-    if (const Fortran::evaluate::Symbol *xs = x.GetAssumedTypeDummy()) {
-      if (const Fortran::evaluate::Symbol *ys = y.GetAssumedTypeDummy())
-        return isEqual(*xs, *ys);
-      return false;
-    }
-    return !y.GetAssumedTypeDummy() &&
-           isEqual(*x.UnwrapExpr(), *y.UnwrapExpr());
-  }
+                      const Fortran::evaluate::ActualArgument &y);
   static bool isEqual(const Fortran::evaluate::ProcedureDesignator &x,
-                      const Fortran::evaluate::ProcedureDesignator &y) {
-    return Fortran::common::visit(
-        [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
-  }
+                      const Fortran::evaluate::ProcedureDesignator &y);
   static bool isEqual(const Fortran::evaluate::ProcedureRef &x,
-                      const Fortran::evaluate::ProcedureRef &y) {
-    return isEqual(x.proc(), y.proc()) && isEqual(x.arguments(), y.arguments());
-  }
+                      const Fortran::evaluate::ProcedureRef &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::ArrayConstructor<A> &x,
-                      const Fortran::evaluate::ArrayConstructor<A> &y) {
-    llvm::report_fatal_error("not implemented");
-  }
+                      const Fortran::evaluate::ArrayConstructor<A> &y);
   static bool isEqual(const Fortran::evaluate::ImpliedDoIndex &x,
-                      const Fortran::evaluate::ImpliedDoIndex &y) {
-    return toStringRef(x.name) == toStringRef(y.name);
-  }
+                      const Fortran::evaluate::ImpliedDoIndex &y);
   static bool isEqual(const Fortran::evaluate::TypeParamInquiry &x,
-                      const Fortran::evaluate::TypeParamInquiry &y) {
-    return isEqual(x.base(), y.base()) && isEqual(x.parameter(), y.parameter());
-  }
+                      const Fortran::evaluate::TypeParamInquiry &y);
   static bool isEqual(const Fortran::evaluate::DescriptorInquiry &x,
-                      const Fortran::evaluate::DescriptorInquiry &y) {
-    return isEqual(x.base(), y.base()) && x.field() == y.field() &&
-           x.dimension() == y.dimension();
-  }
+                      const Fortran::evaluate::DescriptorInquiry &y);
   static bool isEqual(const Fortran::evaluate::StructureConstructor &x,
-                      const Fortran::evaluate::StructureConstructor &y) {
-    const auto &xValues = x.values();
-    const auto &yValues = y.values();
-    if (xValues.size() != yValues.size())
-      return false;
-    if (x.derivedTypeSpec() != y.derivedTypeSpec())
-      return false;
-    for (const auto &[xSymbol, xValue] : xValues) {
-      auto yIt = yValues.find(xSymbol);
-      // This should probably never happen, since the derived type
-      // should be the same.
-      if (yIt == yValues.end())
-        return false;
-      if (!isEqual(xValue, yIt->second))
-        return false;
-    }
-    return true;
-  }
+                      const Fortran::evaluate::StructureConstructor &y);
   template <int KIND>
   static bool isEqual(const Fortran::evaluate::Not<KIND> &x,
-                      const Fortran::evaluate::Not<KIND> &y) {
-    return isEqual(x.left(), y.left());
-  }
+                      const Fortran::evaluate::Not<KIND> &y);
   template <int KIND>
   static bool isEqual(const Fortran::evaluate::LogicalOperation<KIND> &x,
-                      const Fortran::evaluate::LogicalOperation<KIND> &y) {
-    return isEqual(x.left(), y.left()) && isEqual(x.right(), y.right());
-  }
+                      const Fortran::evaluate::LogicalOperation<KIND> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Relational<A> &x,
-                      const Fortran::evaluate::Relational<A> &y) {
-    return isEqual(x.left(), y.left()) && isEqual(x.right(), y.right());
-  }
+                      const Fortran::evaluate::Relational<A> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Expr<A> &x,
-                      const Fortran::evaluate::Expr<A> &y) {
-    return Fortran::common::visit(
-        [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
-  }
+                      const Fortran::evaluate::Expr<A> &y);
   static bool
   isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &x,
-          const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &y) {
-    return Fortran::common::visit(
-        [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
-  }
+          const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &y);
   template <typename A>
   static bool isEqual(const Fortran::evaluate::Designator<A> &x,
-                      const Fortran::evaluate::Designator<A> &y) {
-    return Fortran::common::visit(
-        [&](const auto &v, const auto &w) { return isEqual(v, w); }, x.u, y.u);
-  }
+                      const Fortran::evaluate::Designator<A> &y);
   template <int BITS>
   static bool isEqual(const Fortran::evaluate::value::Integer<BITS> &x,
-                      const Fortran::evaluate::value::Integer<BITS> &y) {
-    return x == y;
-  }
+                      const Fortran::evaluate::value::Integer<BITS> &y);
   static bool isEqual(const Fortran::evaluate::NullPointer &x,
-                      const Fortran::evaluate::NullPointer &y) {
-    return true;
-  }
+                      const Fortran::evaluate::NullPointer &y);
   template <typename A, typename B,
             std::enable_if_t<!std::is_same_v<A, B>, bool> = true>
-  static bool isEqual(const A &, const B &) {
-    return false;
-  }
+  static bool isEqual(const A &, const B &);
 };
 
 static inline unsigned getHashValue(const Fortran::lower::SomeExpr *x) {
@@ -671,4 +371,7159 @@ static inline bool isEqual(const Fortran::lower::SomeExpr *x,
 }
 } // end namespace Fortran::lower
 
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<10> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<16> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<2> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<3> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<4> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<8> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<10> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<16> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<2> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<3> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<4> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<8> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Concat<1> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Concat<2> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Concat<4> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Character>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Complex>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Integer>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Logical>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Real>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Unsigned>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<1> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<2> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<4> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<8> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<1> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<2> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<4> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<8> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::SetLength<1> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::SetLength<2> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::SetLength<4> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::value::Integer<128> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::ActualArgument> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &);
+extern template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::NamedEntity> &);
+
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &, const Fortran::evaluate::SpecificIntrinsic &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &, const Fortran::evaluate::Triplet &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::ArrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::CoarrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::ComplexPart &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::Component &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::SpecificIntrinsic &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::Substring &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::StructureConstructor &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::CoarrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::ComplexPart &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::Component &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::Substring &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::ArrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::ComplexPart &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::Component &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::Substring &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::evaluate::ArrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::evaluate::CoarrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::evaluate::Component &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::ArrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::CoarrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::ComplexPart &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::Substring &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::StructureConstructor &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DataRef &, const std::shared_ptr<Fortran::evaluate::StaticDataObject> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::StructureConstructor &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::StructureConstructor &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::StructureConstructor &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SpecificIntrinsic &, const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SpecificIntrinsic &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::evaluate::ArrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::evaluate::CoarrayRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::evaluate::Component &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Triplet &, const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::DescriptorInquiry &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::ImpliedDoIndex &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::NullPointer &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::ProcedureDesignator &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::ProcedureRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::shared_ptr<Fortran::evaluate::StaticDataObject> &, const Fortran::evaluate::DataRef &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &, const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::SomeType>, true> &, const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::SomeType>, true> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &, const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::ComplexComponent<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::ComplexComponent<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::ComplexComponent<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::ComplexComponent<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::ComplexComponent<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::ComplexComponent<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::ComplexConstructor<10> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::ComplexConstructor<16> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::ComplexConstructor<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::ComplexConstructor<3> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::ComplexConstructor<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::ComplexConstructor<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Concat<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Concat<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Concat<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Character>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Character>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Complex>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Complex>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Integer>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Integer>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Logical>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Logical>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Real>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Real>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Unsigned>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Unsigned>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::LogicalOperation<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::LogicalOperation<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::LogicalOperation<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::LogicalOperation<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Not<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Not<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Not<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Not<8> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::SetLength<1> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::SetLength<2> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::SetLength<4> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::value::Integer<128> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::ActualArgument> &, const std::optional<Fortran::evaluate::ActualArgument> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger>> &, const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &, const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::NamedEntity> &, const std::optional<Fortran::evaluate::NamedEntity> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<Fortran::common::Reference<const Fortran::semantics::Symbol>> &, const std::vector<Fortran::common::Reference<const Fortran::semantics::Symbol>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &, const std::vector<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<Fortran::evaluate::Subscript> &, const std::vector<Fortran::evaluate::Subscript> &);
+extern template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<std::optional<Fortran::evaluate::ActualArgument>> &, const std::vector<std::optional<Fortran::evaluate::ActualArgument>> &);
+
 #endif // FORTRAN_LOWER_SUPPORT_UTILS_H
diff --git a/flang/lib/Lower/CMakeLists.txt b/flang/lib/Lower/CMakeLists.txt
index f611010765cb50..e995a320075f68 100644
--- a/flang/lib/Lower/CMakeLists.txt
+++ b/flang/lib/Lower/CMakeLists.txt
@@ -36,6 +36,7 @@ add_flang_library(FortranLower
   Runtime.cpp
   SymbolMap.cpp
   VectorSubscripts.cpp
+  Support/Utils.cpp
   
   DEPENDS
   CUFAttrs
diff --git a/flang/lib/Lower/Support/Utils.cpp b/flang/lib/Lower/Support/Utils.cpp
new file mode 100644
index 00000000000000..92638bcb2255ec
--- /dev/null
+++ b/flang/lib/Lower/Support/Utils.cpp
@@ -0,0 +1,7757 @@
+#include "flang/Lower/Support/Utils.h"
+
+
+namespace Fortran::lower {
+
+unsigned HashEvaluateExpr::getHashValue(const Fortran::semantics::Symbol &x) {
+  return static_cast<unsigned>(reinterpret_cast<std::intptr_t>(&x));
+}
+template <typename A, bool COPY>
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::common::Indirection<A, COPY> &x) {
+  return HashEvaluateExpr::getHashValue(x.value());
+}
+template <typename A>
+unsigned HashEvaluateExpr::getHashValue(const std::optional<A> &x) {
+  if (x.has_value())
+    return HashEvaluateExpr::getHashValue(x.value());
+  return 0u;
+}
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subscript &x) {
+  return Fortran::common::visit(
+      [&](const auto &v) { return HashEvaluateExpr::getHashValue(v); }, x.u);
+}
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::Triplet &x) {
+  return HashEvaluateExpr::getHashValue(x.lower()) -
+         getHashValue(x.upper()) * 5u -
+         HashEvaluateExpr::getHashValue(x.stride()) * 11u;
+}
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::Component &x) {
+  return HashEvaluateExpr::getHashValue(x.base()) * 83u -
+         getHashValue(x.GetLastSymbol());
+}
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayRef &x) {
+  unsigned subs = 1u;
+  for (const Fortran::evaluate::Subscript &v : x.subscript())
+    subs -= HashEvaluateExpr::getHashValue(v);
+  return HashEvaluateExpr::getHashValue(x.base()) * 89u - subs;
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::CoarrayRef &x) {
+  unsigned subs = 1u;
+  for (const Fortran::evaluate::Subscript &v : x.subscript())
+    subs -= HashEvaluateExpr::getHashValue(v);
+  unsigned cosubs = 3u;
+  for (const Fortran::evaluate::Expr<Fortran::evaluate::SubscriptInteger> &v :
+       x.cosubscript())
+    cosubs -= HashEvaluateExpr::getHashValue(v);
+  unsigned syms = 7u;
+  for (const Fortran::evaluate::SymbolRef &v : x.base())
+    syms += HashEvaluateExpr::getHashValue(v);
+  return syms * 97u - subs - cosubs + HashEvaluateExpr::getHashValue(x.stat()) +
+         257u + HashEvaluateExpr::getHashValue(x.team());
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::NamedEntity &x) {
+  if (x.IsSymbol())
+    return HashEvaluateExpr::getHashValue(x.GetFirstSymbol()) * 11u;
+  return HashEvaluateExpr::getHashValue(x.GetComponent()) * 13u;
+}
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::DataRef &x) {
+  return Fortran::common::visit(
+      [&](const auto &v) { return HashEvaluateExpr::getHashValue(v); }, x.u);
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexPart &x) {
+  return HashEvaluateExpr::getHashValue(x.complex()) -
+         static_cast<unsigned>(x.part());
+}
+template <Fortran::common::TypeCategory TC1, int KIND,
+          Fortran::common::TypeCategory TC2>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Convert<Fortran::evaluate::Type<TC1, KIND>, TC2>
+        &x) {
+  return HashEvaluateExpr::getHashValue(x.left()) -
+         (static_cast<unsigned>(TC1) + 2u) - (static_cast<unsigned>(KIND) + 5u);
+}
+template <int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::ComplexComponent<KIND> &x) {
+  return HashEvaluateExpr::getHashValue(x.left()) -
+         (static_cast<unsigned>(x.isImaginaryPart) + 1u) * 3u;
+}
+template <typename T>
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<T> &x) {
+  return HashEvaluateExpr::getHashValue(x.left()) * 17u;
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Negate<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return HashEvaluateExpr::getHashValue(x.left()) -
+         (static_cast<unsigned>(TC) + 5u) - (static_cast<unsigned>(KIND) + 7u);
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Add<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) + getHashValue(x.right())) *
+             23u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Subtract<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) - getHashValue(x.right())) *
+             19u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Multiply<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) + getHashValue(x.right())) *
+             29u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Divide<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) - getHashValue(x.right())) *
+             31u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Power<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) - getHashValue(x.right())) *
+             37u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Extremum<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) + getHashValue(x.right())) *
+             41u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND) +
+         static_cast<unsigned>(x.ordering) * 7u;
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<TC, KIND>>
+        &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) - getHashValue(x.right())) *
+             43u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND);
+}
+template <int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::ComplexConstructor<KIND> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) - getHashValue(x.right())) *
+             47u +
+         static_cast<unsigned>(KIND);
+}
+template <int KIND>
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::Concat<KIND> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) - getHashValue(x.right())) *
+             53u +
+         static_cast<unsigned>(KIND);
+}
+template <int KIND>
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::SetLength<KIND> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) - getHashValue(x.right())) *
+             59u +
+         static_cast<unsigned>(KIND);
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::semantics::SymbolRef &sym) {
+  return HashEvaluateExpr::getHashValue(sym.get());
+}
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::Substring &x) {
+  return 61u * Fortran::common::visit(
+                   [&](const auto &p) {
+                     return HashEvaluateExpr::getHashValue(p);
+                   },
+                   x.parent()) -
+         HashEvaluateExpr::getHashValue(x.lower()) -
+         (getHashValue(x.lower()) + 1u);
+}
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::StaticDataObject::Pointer &x) {
+  return llvm::hash_value(x->name());
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::SpecificIntrinsic &x) {
+  return llvm::hash_value(x.name);
+}
+template <typename A>
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<A> &x) {
+  // FIXME: Should hash the content.
+  return 103u;
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::ActualArgument &x) {
+  if (const Fortran::evaluate::Symbol *sym = x.GetAssumedTypeDummy())
+    return HashEvaluateExpr::getHashValue(*sym);
+  return HashEvaluateExpr::getHashValue(*x.UnwrapExpr());
+}
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::ProcedureDesignator &x) {
+  return Fortran::common::visit(
+      [&](const auto &v) { return HashEvaluateExpr::getHashValue(v); }, x.u);
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::ProcedureRef &x) {
+  unsigned args = 13u;
+  for (const std::optional<Fortran::evaluate::ActualArgument> &v :
+       x.arguments())
+    args -= HashEvaluateExpr::getHashValue(v);
+  return HashEvaluateExpr::getHashValue(x.proc()) * 101u - args;
+}
+template <typename A>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::ArrayConstructor<A> &x) {
+  // FIXME: hash the contents.
+  return 127u;
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::ImpliedDoIndex &x) {
+  return llvm::hash_value(toStringRef(x.name).str()) * 131u;
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::TypeParamInquiry &x) {
+  return HashEvaluateExpr::getHashValue(x.base()) * 137u -
+         getHashValue(x.parameter()) * 3u;
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::DescriptorInquiry &x) {
+  return HashEvaluateExpr::getHashValue(x.base()) * 139u -
+         static_cast<unsigned>(x.field()) * 13u +
+         static_cast<unsigned>(x.dimension());
+}
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::StructureConstructor &x) {
+  // FIXME: hash the contents.
+  return 149u;
+}
+template <int KIND>
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<KIND> &x) {
+  return HashEvaluateExpr::getHashValue(x.left()) * 61u +
+         static_cast<unsigned>(KIND);
+}
+template <int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::LogicalOperation<KIND> &x) {
+  unsigned result =
+      HashEvaluateExpr::getHashValue(x.left()) + getHashValue(x.right());
+  return result * 67u + static_cast<unsigned>(x.logicalOperator) * 5u;
+}
+template <Fortran::common::TypeCategory TC, int KIND>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Relational<Fortran::evaluate::Type<TC, KIND>> &x) {
+  return (HashEvaluateExpr::getHashValue(x.left()) + getHashValue(x.right())) *
+             71u +
+         static_cast<unsigned>(TC) + static_cast<unsigned>(KIND) +
+         static_cast<unsigned>(x.opr) * 11u;
+}
+template <typename A>
+unsigned HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<A> &x) {
+  return Fortran::common::visit(
+      [&](const auto &v) { return HashEvaluateExpr::getHashValue(v); }, x.u);
+}
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &x) {
+  return Fortran::common::visit(
+      [&](const auto &v) { return HashEvaluateExpr::getHashValue(v); }, x.u);
+}
+template <typename A>
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<A> &x) {
+  return Fortran::common::visit(
+      [&](const auto &v) { return HashEvaluateExpr::getHashValue(v); }, x.u);
+}
+template <int BITS>
+unsigned HashEvaluateExpr::getHashValue(
+    const Fortran::evaluate::value::Integer<BITS> &x) {
+  return static_cast<unsigned>(x.ToSInt());
+}
+unsigned
+HashEvaluateExpr::getHashValue(const Fortran::evaluate::NullPointer &x) {
+  return ~179u;
+}
+
+
+bool IsEqualEvaluateExpr::isEqual(const Fortran::semantics::Symbol &x,
+                                  const Fortran::semantics::Symbol &y) {
+  return IsEqualEvaluateExpr::isEqual(&x, &y);
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::semantics::Symbol *x,
+                                  const Fortran::semantics::Symbol *y) {
+  return x == y;
+}
+template <typename A, bool COPY>
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::common::Indirection<A, COPY> &x,
+    const Fortran::common::Indirection<A, COPY> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.value(), y.value());
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const std::optional<A> &x,
+                                  const std::optional<A> &y) {
+  if (x.has_value() && y.has_value())
+    return IsEqualEvaluateExpr::isEqual(x.value(), y.value());
+  return !x.has_value() && !y.has_value();
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const std::vector<A> &x,
+                                  const std::vector<A> &y) {
+  if (x.size() != y.size())
+    return false;
+  const std::size_t size = x.size();
+  for (std::remove_const_t<decltype(size)> i = 0; i < size; ++i)
+    if (!IsEqualEvaluateExpr::isEqual(x[i], y[i]))
+      return false;
+  return true;
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subscript &x,
+                                  const Fortran::evaluate::Subscript &y) {
+  return Fortran::common::visit(
+      [&](const auto &v, const auto &w) {
+        return IsEqualEvaluateExpr::isEqual(v, w);
+      },
+      x.u, y.u);
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Triplet &x,
+                                  const Fortran::evaluate::Triplet &y) {
+  return IsEqualEvaluateExpr::isEqual(x.lower(), y.lower()) &&
+         IsEqualEvaluateExpr::isEqual(x.upper(), y.upper()) &&
+         IsEqualEvaluateExpr::isEqual(x.stride(), y.stride());
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &x,
+                                  const Fortran::evaluate::Component &y) {
+  return IsEqualEvaluateExpr::isEqual(x.base(), y.base()) &&
+         IsEqualEvaluateExpr::isEqual(x.GetLastSymbol(), y.GetLastSymbol());
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &x,
+                                  const Fortran::evaluate::ArrayRef &y) {
+  return IsEqualEvaluateExpr::isEqual(x.base(), y.base()) &&
+         IsEqualEvaluateExpr::isEqual(x.subscript(), y.subscript());
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &x,
+                                  const Fortran::evaluate::CoarrayRef &y) {
+  return IsEqualEvaluateExpr::isEqual(x.base(), y.base()) &&
+         IsEqualEvaluateExpr::isEqual(x.subscript(), y.subscript()) &&
+         IsEqualEvaluateExpr::isEqual(x.cosubscript(), y.cosubscript()) &&
+         IsEqualEvaluateExpr::isEqual(x.stat(), y.stat()) &&
+         IsEqualEvaluateExpr::isEqual(x.team(), y.team());
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NamedEntity &x,
+                                  const Fortran::evaluate::NamedEntity &y) {
+  if (x.IsSymbol() && y.IsSymbol())
+    return IsEqualEvaluateExpr::isEqual(x.GetFirstSymbol(), y.GetFirstSymbol());
+  return !x.IsSymbol() && !y.IsSymbol() &&
+         IsEqualEvaluateExpr::isEqual(x.GetComponent(), y.GetComponent());
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DataRef &x,
+                                  const Fortran::evaluate::DataRef &y) {
+  return Fortran::common::visit(
+      [&](const auto &v, const auto &w) {
+        return IsEqualEvaluateExpr::isEqual(v, w);
+      },
+      x.u, y.u);
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &x,
+                                  const Fortran::evaluate::ComplexPart &y) {
+  return IsEqualEvaluateExpr::isEqual(x.complex(), y.complex()) &&
+         x.part() == y.part();
+}
+template <typename A, Fortran::common::TypeCategory TC2>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<A, TC2> &x,
+                                  const Fortran::evaluate::Convert<A, TC2> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left());
+}
+template <int KIND>
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::ComplexComponent<KIND> &x,
+    const Fortran::evaluate::ComplexComponent<KIND> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left()) &&
+         x.isImaginaryPart == y.isImaginaryPart;
+}
+template <typename T>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<T> &x,
+                                  const Fortran::evaluate::Parentheses<T> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left());
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<A> &x,
+                                  const Fortran::evaluate::Negate<A> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left());
+}
+template <typename A> bool isBinaryEqual(const A &x, const A &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left()) &&
+         IsEqualEvaluateExpr::isEqual(x.right(), y.right());
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<A> &x,
+                                  const Fortran::evaluate::Add<A> &y) {
+  return isBinaryEqual(x, y);
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<A> &x,
+                                  const Fortran::evaluate::Subtract<A> &y) {
+  return isBinaryEqual(x, y);
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<A> &x,
+                                  const Fortran::evaluate::Multiply<A> &y) {
+  return isBinaryEqual(x, y);
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<A> &x,
+                                  const Fortran::evaluate::Divide<A> &y) {
+  return isBinaryEqual(x, y);
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<A> &x,
+                                  const Fortran::evaluate::Power<A> &y) {
+  return isBinaryEqual(x, y);
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<A> &x,
+                                  const Fortran::evaluate::Extremum<A> &y) {
+  return isBinaryEqual(x, y);
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::RealToIntPower<A> &x,
+    const Fortran::evaluate::RealToIntPower<A> &y) {
+  return isBinaryEqual(x, y);
+}
+template <int KIND>
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::ComplexConstructor<KIND> &x,
+    const Fortran::evaluate::ComplexConstructor<KIND> &y) {
+  return isBinaryEqual(x, y);
+}
+template <int KIND>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<KIND> &x,
+                                  const Fortran::evaluate::Concat<KIND> &y) {
+  return isBinaryEqual(x, y);
+}
+template <int KIND>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<KIND> &x,
+                                  const Fortran::evaluate::SetLength<KIND> &y) {
+  return isBinaryEqual(x, y);
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::semantics::SymbolRef &x,
+                                  const Fortran::semantics::SymbolRef &y) {
+  return IsEqualEvaluateExpr::isEqual(x.get(), y.get());
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &x,
+                                  const Fortran::evaluate::Substring &y) {
+  return Fortran::common::visit(
+             [&](const auto &p, const auto &q) {
+               return IsEqualEvaluateExpr::isEqual(p, q);
+             },
+             x.parent(), y.parent()) &&
+         IsEqualEvaluateExpr::isEqual(x.lower(), y.lower()) &&
+         IsEqualEvaluateExpr::isEqual(x.upper(), y.upper());
+}
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::StaticDataObject::Pointer &x,
+    const Fortran::evaluate::StaticDataObject::Pointer &y) {
+  return x->name() == y->name();
+}
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::SpecificIntrinsic &x,
+    const Fortran::evaluate::SpecificIntrinsic &y) {
+  return x.name == y.name;
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<A> &x,
+                                  const Fortran::evaluate::Constant<A> &y) {
+  return x == y;
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ActualArgument &x,
+                                  const Fortran::evaluate::ActualArgument &y) {
+  if (const Fortran::evaluate::Symbol *xs = x.GetAssumedTypeDummy()) {
+    if (const Fortran::evaluate::Symbol *ys = y.GetAssumedTypeDummy())
+      return IsEqualEvaluateExpr::isEqual(*xs, *ys);
+    return false;
+  }
+  return !y.GetAssumedTypeDummy() &&
+         IsEqualEvaluateExpr::isEqual(*x.UnwrapExpr(), *y.UnwrapExpr());
+}
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::ProcedureDesignator &x,
+    const Fortran::evaluate::ProcedureDesignator &y) {
+  return Fortran::common::visit(
+      [&](const auto &v, const auto &w) {
+        return IsEqualEvaluateExpr::isEqual(v, w);
+      },
+      x.u, y.u);
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &x,
+                                  const Fortran::evaluate::ProcedureRef &y) {
+  return IsEqualEvaluateExpr::isEqual(x.proc(), y.proc()) &&
+         IsEqualEvaluateExpr::isEqual(x.arguments(), y.arguments());
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::ArrayConstructor<A> &x,
+    const Fortran::evaluate::ArrayConstructor<A> &y) {
+  llvm::report_fatal_error("not implemented");
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &x,
+                                  const Fortran::evaluate::ImpliedDoIndex &y) {
+  return toStringRef(x.name) == toStringRef(y.name);
+}
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::TypeParamInquiry &x,
+    const Fortran::evaluate::TypeParamInquiry &y) {
+  return IsEqualEvaluateExpr::isEqual(x.base(), y.base()) &&
+         IsEqualEvaluateExpr::isEqual(x.parameter(), y.parameter());
+}
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::DescriptorInquiry &x,
+    const Fortran::evaluate::DescriptorInquiry &y) {
+  return IsEqualEvaluateExpr::isEqual(x.base(), y.base()) &&
+         x.field() == y.field() && x.dimension() == y.dimension();
+}
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::StructureConstructor &x,
+    const Fortran::evaluate::StructureConstructor &y) {
+  const auto &xValues = x.values();
+  const auto &yValues = y.values();
+  if (xValues.size() != yValues.size())
+    return false;
+  if (x.derivedTypeSpec() != y.derivedTypeSpec())
+    return false;
+  for (const auto &[xSymbol, xValue] : xValues) {
+    auto yIt = yValues.find(xSymbol);
+    // This should probably never happen, since the derived type
+    // should be the same.
+    if (yIt == yValues.end())
+      return false;
+    if (!IsEqualEvaluateExpr::isEqual(xValue, yIt->second))
+      return false;
+  }
+  return true;
+}
+template <int KIND>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<KIND> &x,
+                                  const Fortran::evaluate::Not<KIND> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left());
+}
+template <int KIND>
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::LogicalOperation<KIND> &x,
+    const Fortran::evaluate::LogicalOperation<KIND> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left()) &&
+         IsEqualEvaluateExpr::isEqual(x.right(), y.right());
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<A> &x,
+                                  const Fortran::evaluate::Relational<A> &y) {
+  return IsEqualEvaluateExpr::isEqual(x.left(), y.left()) &&
+         IsEqualEvaluateExpr::isEqual(x.right(), y.right());
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<A> &x,
+                                  const Fortran::evaluate::Expr<A> &y) {
+  return Fortran::common::visit(
+      [&](const auto &v, const auto &w) {
+        return IsEqualEvaluateExpr::isEqual(v, w);
+      },
+      x.u, y.u);
+}
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &x,
+    const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &y) {
+  return Fortran::common::visit(
+      [&](const auto &v, const auto &w) {
+        return IsEqualEvaluateExpr::isEqual(v, w);
+      },
+      x.u, y.u);
+}
+template <typename A>
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<A> &x,
+                                  const Fortran::evaluate::Designator<A> &y) {
+  return Fortran::common::visit(
+      [&](const auto &v, const auto &w) {
+        return IsEqualEvaluateExpr::isEqual(v, w);
+      },
+      x.u, y.u);
+}
+template <int BITS>
+bool IsEqualEvaluateExpr::isEqual(
+    const Fortran::evaluate::value::Integer<BITS> &x,
+    const Fortran::evaluate::value::Integer<BITS> &y) {
+  return x == y;
+}
+bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &x,
+                                  const Fortran::evaluate::NullPointer &y) {
+  return true;
+}
+template <typename A, typename B,
+          std::enable_if_t<!std::is_same_v<A, B>, bool> = true>
+bool IsEqualEvaluateExpr::isEqual(const A &, const B &) {
+  return false;
+}
+} // namespace Fortran::lower
+
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<10> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<16> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<2> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<3> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<4> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexComponent<8> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<10> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<16> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<2> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<3> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<4> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ComplexConstructor<8> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Concat<1> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Concat<2> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Concat<4> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Character>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Complex>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Integer>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Logical>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Real>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Unsigned>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<1> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<2> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<4> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::LogicalOperation<8> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<1> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<2> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<4> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Not<8> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::SetLength<1> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::SetLength<2> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::SetLength<4> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::value::Integer<128> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::ActualArgument> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &);
+template unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const std::optional<Fortran::evaluate::NamedEntity> &);
+
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isBinaryEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &, const Fortran::evaluate::SpecificIntrinsic &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &, const Fortran::evaluate::Triplet &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::ArrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::CoarrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::ComplexPart &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::Component &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::SpecificIntrinsic &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Reference<const Fortran::semantics::Symbol> &, const Fortran::evaluate::Substring &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::StructureConstructor &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::CoarrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::ComplexPart &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::Component &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayRef &, const Fortran::evaluate::Substring &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::ArrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::ComplexPart &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::Component &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::CoarrayRef &, const Fortran::evaluate::Substring &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::evaluate::ArrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::evaluate::CoarrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexPart &, const Fortran::evaluate::Component &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::ArrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::CoarrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::ComplexPart &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Component &, const Fortran::evaluate::Substring &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::StructureConstructor &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DataRef &, const std::shared_ptr<Fortran::evaluate::StaticDataObject> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::DescriptorInquiry &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::StructureConstructor &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::StructureConstructor &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ImpliedDoIndex &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &, const Fortran::evaluate::StructureConstructor &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureDesignator &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ProcedureRef &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SpecificIntrinsic &, const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SpecificIntrinsic &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::StructureConstructor &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::common::Reference<const Fortran::semantics::Symbol> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::evaluate::ArrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::evaluate::CoarrayRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Substring &, const Fortran::evaluate::Component &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::TypeParamInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Triplet &, const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::DescriptorInquiry &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::ImpliedDoIndex &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::TypeParamInquiry &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeComplex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeLogical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeReal> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeUnsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::NullPointer &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::ProcedureDesignator &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::ProcedureRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::shared_ptr<Fortran::evaluate::StaticDataObject> &, const Fortran::evaluate::DataRef &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Component, true> &, const Fortran::common::Indirection<Fortran::evaluate::Component, true> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::SomeType>, true> &, const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::SomeType>, true> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &, const Fortran::common::Indirection<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>, true> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<10> &, const Fortran::evaluate::ComplexComponent<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<16> &, const Fortran::evaluate::ComplexComponent<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<2> &, const Fortran::evaluate::ComplexComponent<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<3> &, const Fortran::evaluate::ComplexComponent<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<4> &, const Fortran::evaluate::ComplexComponent<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexComponent<8> &, const Fortran::evaluate::ComplexComponent<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<10> &, const Fortran::evaluate::ComplexConstructor<10> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<16> &, const Fortran::evaluate::ComplexConstructor<16> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<2> &, const Fortran::evaluate::ComplexConstructor<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<3> &, const Fortran::evaluate::ComplexConstructor<3> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<4> &, const Fortran::evaluate::ComplexConstructor<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::ComplexConstructor<8> &, const Fortran::evaluate::ComplexConstructor<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<1> &, const Fortran::evaluate::Concat<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<2> &, const Fortran::evaluate::Concat<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Concat<4> &, const Fortran::evaluate::Concat<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Constant<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Character>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Character>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Complex>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Complex>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Integer>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Integer>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Logical>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Logical>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Real>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Real>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Unsigned>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Unsigned>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &, const Fortran::evaluate::Expr<Fortran::evaluate::SomeType> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<1> &, const Fortran::evaluate::LogicalOperation<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<2> &, const Fortran::evaluate::LogicalOperation<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<4> &, const Fortran::evaluate::LogicalOperation<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::LogicalOperation<8> &, const Fortran::evaluate::LogicalOperation<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<1> &, const Fortran::evaluate::Not<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<2> &, const Fortran::evaluate::Not<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<4> &, const Fortran::evaluate::Not<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Not<8> &, const Fortran::evaluate::Not<8> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &, const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<1> &, const Fortran::evaluate::SetLength<1> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<2> &, const Fortran::evaluate::SetLength<2> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::SetLength<4> &, const Fortran::evaluate::SetLength<4> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &, const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::value::Integer<128> &, const Fortran::evaluate::value::Integer<128> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::ActualArgument> &, const std::optional<Fortran::evaluate::ActualArgument> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger>> &, const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::SomeInteger>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &, const std::optional<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::optional<Fortran::evaluate::NamedEntity> &, const std::optional<Fortran::evaluate::NamedEntity> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<Fortran::common::Reference<const Fortran::semantics::Symbol>> &, const std::vector<Fortran::common::Reference<const Fortran::semantics::Symbol>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &, const std::vector<Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>>> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<Fortran::evaluate::Subscript> &, const std::vector<Fortran::evaluate::Subscript> &);
+template bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const std::vector<std::optional<Fortran::evaluate::ActualArgument>> &, const std::vector<std::optional<Fortran::evaluate::ActualArgument>> &);

>From d732b5d0c106276f0289cc0304dbcebaa38cd9d4 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Wed, 29 Jan 2025 08:56:10 -0600
Subject: [PATCH 2/2] compilation-fixes

---
 flang/lib/Lower/Support/Utils.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/flang/lib/Lower/Support/Utils.cpp b/flang/lib/Lower/Support/Utils.cpp
index 92638bcb2255ec..af7eeaccf595ad 100644
--- a/flang/lib/Lower/Support/Utils.cpp
+++ b/flang/lib/Lower/Support/Utils.cpp
@@ -388,7 +388,8 @@ bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Negate<A> &x,
                                   const Fortran::evaluate::Negate<A> &y) {
   return IsEqualEvaluateExpr::isEqual(x.left(), y.left());
 }
-template <typename A> bool isBinaryEqual(const A &x, const A &y) {
+template <typename A>
+bool IsEqualEvaluateExpr::isBinaryEqual(const A &x, const A &y) {
   return IsEqualEvaluateExpr::isEqual(x.left(), y.left()) &&
          IsEqualEvaluateExpr::isEqual(x.right(), y.right());
 }
@@ -594,8 +595,7 @@ bool IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::NullPointer &x,
                                   const Fortran::evaluate::NullPointer &y) {
   return true;
 }
-template <typename A, typename B,
-          std::enable_if_t<!std::is_same_v<A, B>, bool> = true>
+template <typename A, typename B, std::enable_if_t<!std::is_same_v<A, B>, bool>>
 bool IsEqualEvaluateExpr::isEqual(const A &, const B &) {
   return false;
 }