[flang-commits] [flang] [flang][Lower] Explicitly instantiate all templates from Utils.h (PR #125216)

[Krzysztof Parzyszek via flang-commits]

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

>From 31d9ad8b7e04781052f6c684fe890bbfc6847433 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/3] [flang][Lower] Explicitly instantiate all templates from
 Utils.h

This is intended to reduce the memory usage while compiling flang sources.
Specifically, this reduced the peak memory use when compiling OpenMP.cpp
(on my machine) from 4.9g to 3.6g.

The change was to only leave template declarations in the header file and
explicitly instantiate every case that was previously instantiated
implicitly. If a new implicit instantiation appears later on, it will
cause a compilation error (and the explicit instantiation will need to be
added manually).

Most of the instantiation declarations are generated by an included python
script (about 6000 cases). The remaining cases (~1000) are listed
explicitly.
---
 flang/include/flang/Lower/Support/Utils.h     | 1446 ++--
 .../Lower/Support/UtilsInstantiations.def     | 6214 +++++++++++++++++
 .../print-instantiation-declarations.py       |  300 +
 flang/lib/Lower/CMakeLists.txt                |    1 +
 flang/lib/Lower/Support/Utils.cpp             | 1563 +++++
 5 files changed, 9130 insertions(+), 394 deletions(-)
 create mode 100644 flang/include/flang/Lower/Support/UtilsInstantiations.def
 create mode 100644 flang/include/flang/Lower/Support/print-instantiation-declarations.py
 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 1cc74521e22d888..601274ceef4a834 100644
--- a/flang/include/flang/Lower/Support/Utils.h
+++ b/flang/include/flang/Lower/Support/Utils.h
@@ -86,6 +86,11 @@ A flatZip(const A &container1, const A &container2) {
   return result;
 }
 
+// NOTE: Due to excessive memory usage during implicit instantiations,
+//       template definitions were moved to Utils.cpp, leaving only
+//       template declarations in this file.
+//       Any templates that would be implicitly instantiated were declared
+//       as externally explicitly instantiated.
 namespace Fortran::lower {
 // Fortran::evaluate::Expr are functional values organized like an AST. A
 // Fortran::evaluate::Expr is meant to be moved and cloned. Using the front end
@@ -106,247 +111,97 @@ 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());
-  }
+  static unsigned getHashValue(const Fortran::common::Indirection<A, COPY> &x);
   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 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 +211,130 @@ 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());
-  }
+                      const Fortran::evaluate::Negate<A> &y);
   template <typename A>
-  static bool isBinaryEqual(const A &x, const A &y) {
-    return isEqual(x.left(), y.left()) && isEqual(x.right(), y.right());
-  }
+  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 +378,955 @@ static inline bool isEqual(const Fortran::lower::SomeExpr *x,
 }
 } // end namespace Fortran::lower
 
+#define INSTANTIATION(x) extern template x
+#include "UtilsInstantiations.def"
+#undef INSTANTIATION
+
+// The instantiations below are not generated by the
+// print-instantiation-declarations.py script.
+
+// clang-format off
+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::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+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::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+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::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::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::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::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::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::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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::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::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::SetLength<4> &);
+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, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::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, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexComponent<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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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::Concat<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::Concat<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::Concat<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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::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, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexComponent<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::ComplexConstructor<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::ComplexConstructor<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::ComplexConstructor<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::ComplexConstructor<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::ComplexConstructor<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::ComplexConstructor<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::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::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::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::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::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::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::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::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::TypeParamInquiry &);
+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::LogicalOperation<1> &);
+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::Not<1> &);
+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::LogicalOperation<2> &);
+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::Not<2> &);
+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::LogicalOperation<4> &);
+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::Not<4> &);
+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::Relational<Fortran::evaluate::SomeType> &);
+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::LogicalOperation<8> &);
+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::Not<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<8> &);
+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::Concat<1> &);
+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::SetLength<1> &);
+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::Concat<2> &);
+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::SetLength<2> &);
+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::Concat<4> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::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, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+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::SetLength<1> &);
+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::SetLength<2> &);
+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::SetLength<4> &);
+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, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::SetLength<1> &);
+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::SetLength<2> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::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, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexComponent<8> &);
+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::SetLength<1> &);
+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::SetLength<2> &);
+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::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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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::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::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::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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::SetLength<1> &);
+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::SetLength<2> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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, 16>> &, const Fortran::evaluate::ComplexComponent<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexComponent<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexComponent<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>, Fortran::common::TypeCategory::Logical> &);
+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::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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::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::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::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::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::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::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::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::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>> &);
+// clang-format on
+
 #endif // FORTRAN_LOWER_SUPPORT_UTILS_H
diff --git a/flang/include/flang/Lower/Support/UtilsInstantiations.def b/flang/include/flang/Lower/Support/UtilsInstantiations.def
new file mode 100644
index 000000000000000..d144b65fab43661
--- /dev/null
+++ b/flang/include/flang/Lower/Support/UtilsInstantiations.def
@@ -0,0 +1,6214 @@
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 2>, Fortran::common::TypeCategory::Complex> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 3>, Fortran::common::TypeCategory::Complex> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 4>, Fortran::common::TypeCategory::Complex> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 8>, Fortran::common::TypeCategory::Complex> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 10>, Fortran::common::TypeCategory::Complex> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Complex, 16>, Fortran::common::TypeCategory::Complex> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 1>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 2>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 4>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 8>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer, 16>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 2>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 3>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 4>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 8>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 10>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Power<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::RealToIntPower<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Real, 16>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 1>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 2>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 4>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 8>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Expr<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Add<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Divide<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Multiply<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Negate<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Subtract<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Relational<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Integer> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Real> &));
+INSTANTIATION(unsigned int Fortran::lower::HashEvaluateExpr::getHashValue(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Unsigned, 16>, Fortran::common::TypeCategory::Unsigned> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 1>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 2>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Character> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>, Fortran::common::TypeCategory::Character> &, const Fortran::evaluate::Extremum<Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, 4>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 1>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 2>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 4>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>, Fortran::common::TypeCategory::Logical> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::ArrayConstructor<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Constant<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Designator<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::FunctionRef<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(bool Fortran::lower::IsEqualEvaluateExpr::isEqual(const Fortran::evaluate::Convert<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>, Fortran::common::TypeCategory::Logical> &, const Fortran::evaluate::Parentheses<Fortran::evaluate::Type<Fortran::common::TypeCategory::Logical, 8>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
+INSTANTIATION(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>> &));
diff --git a/flang/include/flang/Lower/Support/print-instantiation-declarations.py b/flang/include/flang/Lower/Support/print-instantiation-declarations.py
new file mode 100644
index 000000000000000..df173906873771e
--- /dev/null
+++ b/flang/include/flang/Lower/Support/print-instantiation-declarations.py
@@ -0,0 +1,300 @@
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# This script generates declarations of hash calculations and equality checks
+# from flang/include/flang/Lower/Support/Utils.h
+# The total number of implicitly instantiated functions was in excess of 7000
+# consuming large amounts of memory at compile time.
+#
+# The script generates declarations of functions which take operands in the
+# form of
+#    Operation<Type<TypeCategory, Kind>>     (*)
+#
+# The main utility is an category-kind iterator, which generates valid pairs
+# of TypeCategory and Kind.
+# This is then used to generate strings with operations in the form of (*).
+# These strings, in turn, are then used to generate the function declarations.
+
+MacroName = "INSTANTIATION"
+
+
+class Category:
+    def __init__(self, name, kinds):
+        self.name = name
+        self.kinds = kinds
+        assert (
+            isinstance(kinds, list) and kinds
+        ), "kinds should be a nonempty list"
+
+    def to_string(self):
+        return f"Fortran::common::TypeCategory::{self.name}"
+
+    def __repr__(self):
+        return self.name
+
+
+Character = Category("Character", [1, 2, 4])
+Complex = Category("Complex", [2, 3, 4, 8, 10, 16])
+Integer = Category("Integer", [1, 2, 4, 8, 16])
+Logical = Category("Logical", [1, 2, 4, 8])
+Real = Category("Real", [2, 3, 4, 8, 10, 16])
+Unsigned = Category("Unsigned", [1, 2, 4, 8, 16])
+
+Categories = [Character, Complex, Integer, Logical, Real, Unsigned]
+
+
+# The main implementation of the category-kind iterator. Implements __next__.
+class CKIteratorImpl:
+    def __init__(self, *, categories=..., kinds=...):
+        self.categories = categories
+        self.kinds = kinds
+        self.category_index = 0
+        self.kind_index = -1
+        self.at_end = False
+
+    def _dereference(self):
+        category = Categories[self.category_index]
+        kind = category.kinds[self.kind_index]
+        return category, kind
+
+    def _is_allowed(self):
+        assert not self.at_end
+        category, kind = self._dereference()
+        if self.kinds is not ... and kind not in self.kinds:
+            return False
+        if self.categories is not ... and category not in self.categories:
+            return False
+        return True
+
+    def _increment(self):
+        if self.at_end:
+            return
+
+        self.kind_index += 1
+        category = Categories[self.category_index]
+
+        if self.kind_index >= len(category.kinds):
+            self.kind_index = 0
+            self.category_index += 1
+
+        if self.category_index >= len(Categories):
+            self.at_end = True
+
+    def __next__(self):
+        if self.at_end:
+            raise StopIteration()
+
+        while not self.at_end:
+            self._increment()
+            if self.at_end:
+                raise StopIteration()
+            if self._is_allowed():
+                break
+
+        return self._dereference()
+
+
+# User interface of the category-kind iterator. Implements __iter__.
+class CKIterator:
+    def __init__(self, *, categories=..., kinds=...):
+        self.categories = categories  # Allowed categories
+        self.kinds = kinds  # Allowed kinds
+
+    def __iter__(self):
+        return CKIteratorImpl(categories=self.categories, kinds=self.kinds)
+
+
+class Type:
+    def __init__(self, category, kind):
+        self.category = category
+        self.kind = kind
+
+    def to_string(self):
+        return (
+            f"Fortran::evaluate::Type<{self.category.to_string()}, "
+            f"{self.kind}>"
+        )
+
+
+ArithCategories = [Complex, Integer, Real, Unsigned]
+
+
+class Op:
+    def __init__(self, name, categories=..., kinds=...):
+        self.name = name
+        self.categories = categories
+        self.kinds = kinds
+
+    def to_strings(self, category, kind):
+        return [
+            f"Fortran::evaluate::{self.name}"
+            f"<{Type(category, kind).to_string()}>"
+        ]
+
+    def __repr__(self):
+        return self.name
+
+
+class ConvertOp(Op):
+    # Conversion classes: for each category c in class: Convert(Type(c), c)
+    Classes = [
+        [Character],
+        [Complex],
+        [Integer, Real, Unsigned],
+        [Logical],
+    ]
+
+    def __init__(self, categories=..., kinds=...):
+        super().__init__("Convert", categories, kinds)
+
+    def to_strings(self, category, kind):
+        for cls in ConvertOp.Classes:
+            if not category in cls:
+                continue
+            cvt_strings = [
+                f"Fortran::evaluate::{self.name}"
+                f"<{Type(category, kind).to_string()}, {to_c.to_string()}>"
+                for to_c in cls
+            ]
+            return cvt_strings
+
+
+GeneralOps = [
+    Op(name)
+    for name in [
+        "ArrayConstructor",
+        "Constant",
+        "Designator",
+        "Expr",
+        "FunctionRef",
+        "Parentheses",
+    ]
+]
+
+MathOps = [
+    Op("Add", ArithCategories),
+    Op("Divide", ArithCategories),
+    Op("Multiply", ArithCategories),
+    Op("Negate", ArithCategories),
+    Op("Subtract", ArithCategories),
+    Op("Extremum", [Character, Integer, Real, Unsigned]),
+    Op("Power", [Complex, Integer, Real]),
+    Op("RealToIntPower", [Complex, Real]),
+]
+
+OtherOps = [
+    Op("Relational", [Character, Complex, Integer, Real, Unsigned]),
+    ConvertOp(),
+]
+
+
+# Construct a dictionary:
+#   (category, kind) -> {
+#     {op: [string-for-op-with-category-kind]}
+#   }
+# for all valid combinations of category and kind.
+#
+# The entry for a given pair (category, kind) is another dictionary that
+# is indexed by operations, and contains the strings representing that
+# operation with the given category and kind. Usually there is only one
+# string like that, e.g.
+#   {Add: ["Add<TypeCategory::Integer, 8>"]}
+# with the exception of the Convert operation, which contains extra category
+# parameter (but without an extra kind), e.g.:
+#   Convert<Type<TypeCategory::Integer, 4>, TypeCategory::Integer>
+#   Convert<Type<TypeCategory::Integer, 4>, TypeCategory::Real>
+#   Convert<Type<TypeCategory::Integer, 4>, TypeCategory::Unsigned>
+# In such case the list of strings will contain all of these.
+
+
+def build_dict():
+    opstr_dict = {}
+
+    def update(c, k, op, strings):
+        if entry := opstr_dict.get((c, k)):
+            if ss := entry.get(op):
+                ss.append(strings)
+            else:
+                entry[op] = strings
+        else:
+            opstr_dict[c, k] = {op: strings}
+
+    for op in [*GeneralOps, *MathOps, *OtherOps]:
+        for c, k in CKIterator(categories=op.categories):
+            update(c, k, op, op.to_strings(c, k))
+
+    return opstr_dict
+
+
+def print_getHashValue(opstr_dict):
+    format_string = (
+        f"{MacroName}(unsigned int Fortran::lower::HashEvaluateExpr::"
+        f"getHashValue(const {{0}} &));"
+    )
+
+    for (c, k), entry in opstr_dict.items():
+        for op, strings in entry.items():
+            if op.name in ["FunctionRef"]:
+                continue
+            for s in strings:
+                print(format_string.format(s))
+
+
+def print_isBinaryEqual(opstr_dict):
+    format_string = (
+        f"{MacroName}(bool Fortran::lower::IsEqualEvaluateExpr::"
+        f"isBinaryEqual(const {{0}} &, const {{0}} &));"
+    )
+
+    for (c, k), entry in opstr_dict.items():
+        for op, strings in entry.items():
+            if op not in MathOps or op.name in ["Negate"]:
+                continue
+            for s in strings:
+                print(format_string.format(s))
+
+
+def print_isEqual(opstr_dict):
+    format_string = (
+        f"{MacroName}(bool Fortran::lower::IsEqualEvaluateExpr::"
+        f"isEqual(const {{0}} &, const {{1}} &));"
+    )
+
+    for (c0, k), entry in opstr_dict.items():
+        for op0, strings0 in entry.items():
+            for op1, strings1 in entry.items():
+                # Expr and Relational are handled separately
+                if op0.name in ["Expr", "Relational"]:
+                    continue
+                if op1.name in ["Expr", "Relational"]:
+                    continue
+                # FunctionRef does not appear with another FunctionRef.
+                if op0.name == "FunctionRef" and op1.name == "FunctionRef":
+                    continue
+                for s0, s1 in [(x, y) for x in strings0 for y in strings1]:
+                    print(format_string.format(s0, s1))
+
+    # Expr and Relational are only paired with themselves, but across
+    # different sets of types:
+    # - Expr is over kinds within the same category,
+    # - Relational is over all types
+    for (c0, k0), entry0 in opstr_dict.items():
+        for op0, strings0 in entry0.items():
+            if op0.name not in ["Expr", "Relational"]:
+                continue
+            for (c1, k1), entry1 in opstr_dict.items():
+                for op1, strings1 in entry1.items():
+                    if op0.name != op1.name:
+                        continue
+                    if op0.name == "Expr" and c0 != c1:
+                        continue
+                    for s0, s1 in [(x, y) for x in strings0 for y in strings1]:
+                        print(format_string.format(s0, s1))
+
+
+opstr_dict = build_dict()
+
+print_getHashValue(opstr_dict)
+print_isBinaryEqual(opstr_dict)
+print_isEqual(opstr_dict)
diff --git a/flang/lib/Lower/CMakeLists.txt b/flang/lib/Lower/CMakeLists.txt
index f611010765cb505..e995a320075f68f 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 000000000000000..ff9b12f14e90af4
--- /dev/null
+++ b/flang/lib/Lower/Support/Utils.cpp
@@ -0,0 +1,1563 @@
+//===-- Lower/Support/Utils.cpp -- utilities --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#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 IsEqualEvaluateExpr::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>>
+bool IsEqualEvaluateExpr::isEqual(const A &, const B &) {
+  return false;
+}
+} // namespace Fortran::lower
+
+#define INSTANTIATION(x) template x
+#include "flang/Lower/Support/UtilsInstantiations.def"
+#undef INSTANTIATION
+
+// The instantiations below are not generated by the
+// print-instantiation-declarations.py script.
+
+// clang-format off
+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::ArrayConstructor<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+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::Designator<Fortran::evaluate::SomeKind<Fortran::common::TypeCategory::Derived>> &);
+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::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::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::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::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::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::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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::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::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::SetLength<4> &);
+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, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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::Concat<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::Concat<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::Concat<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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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, 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, 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, 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, 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, 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::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::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::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::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::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::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::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::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::TypeParamInquiry &);
+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::LogicalOperation<1> &);
+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::Not<1> &);
+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::LogicalOperation<2> &);
+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::Not<2> &);
+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::LogicalOperation<4> &);
+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::Not<4> &);
+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::Relational<Fortran::evaluate::SomeType> &);
+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::LogicalOperation<8> &);
+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::Not<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<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::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::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::ComplexComponent<8> &);
+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::Concat<1> &);
+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::SetLength<1> &);
+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::Concat<2> &);
+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::SetLength<2> &);
+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::Concat<4> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::SetLength<1> &);
+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::SetLength<2> &);
+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::SetLength<4> &);
+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, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::SetLength<1> &);
+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::SetLength<2> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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, 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, 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::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::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::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::SetLength<1> &);
+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::SetLength<2> &);
+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::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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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, 16>> &, const Fortran::evaluate::ComplexConstructor<16> &);
+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, 3>> &, const Fortran::evaluate::ComplexConstructor<3> &);
+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, 8>> &, const Fortran::evaluate::ComplexConstructor<8> &);
+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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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>, Fortran::common::TypeCategory::Logical> &);
+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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::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::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::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::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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::SetLength<1> &);
+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::SetLength<2> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::Real, 10>> &, const Fortran::evaluate::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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>, Fortran::common::TypeCategory::Logical> &);
+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::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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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>, Fortran::common::TypeCategory::Character> &);
+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::ComplexConstructor<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexConstructor<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexConstructor<4> &);
+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::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::ImpliedDoIndex &);
+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::ComplexComponent<10> &);
+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, 2>> &, const Fortran::evaluate::ComplexComponent<2> &);
+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, 4>> &, const Fortran::evaluate::ComplexComponent<4> &);
+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::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::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::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::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::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::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::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::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::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>> &);
+// clang-format on

>From 3b243ee915d81bb3e080cd972614893d7dd8e4c4 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Fri, 31 Jan 2025 07:04:10 -0600
Subject: [PATCH 2/3] format

---
 .../Lower/Support/print-instantiation-declarations.py | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/flang/include/flang/Lower/Support/print-instantiation-declarations.py b/flang/include/flang/Lower/Support/print-instantiation-declarations.py
index df173906873771e..b221cf01cf97ea0 100644
--- a/flang/include/flang/Lower/Support/print-instantiation-declarations.py
+++ b/flang/include/flang/Lower/Support/print-instantiation-declarations.py
@@ -23,9 +23,7 @@ class Category:
     def __init__(self, name, kinds):
         self.name = name
         self.kinds = kinds
-        assert (
-            isinstance(kinds, list) and kinds
-        ), "kinds should be a nonempty list"
+        assert isinstance(kinds, list) and kinds, "kinds should be a nonempty list"
 
     def to_string(self):
         return f"Fortran::common::TypeCategory::{self.name}"
@@ -111,9 +109,7 @@ def __init__(self, category, kind):
         self.kind = kind
 
     def to_string(self):
-        return (
-            f"Fortran::evaluate::Type<{self.category.to_string()}, "
-            f"{self.kind}>"
+        return f"Fortran::evaluate::Type<{self.category.to_string()}, {self.kind}>"
         )
 
 
@@ -128,8 +124,7 @@ def __init__(self, name, categories=..., kinds=...):
 
     def to_strings(self, category, kind):
         return [
-            f"Fortran::evaluate::{self.name}"
-            f"<{Type(category, kind).to_string()}>"
+            f"Fortran::evaluate::{self.name}<{Type(category, kind).to_string()}>"
         ]
 
     def __repr__(self):

>From d172a45dd66788a1749c8a912759836f8b692312 Mon Sep 17 00:00:00 2001
From: Krzysztof Parzyszek <Krzysztof.Parzyszek at amd.com>
Date: Fri, 31 Jan 2025 07:06:40 -0600
Subject: [PATCH 3/3] delete leftover )

---
 .../flang/Lower/Support/print-instantiation-declarations.py      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/flang/include/flang/Lower/Support/print-instantiation-declarations.py b/flang/include/flang/Lower/Support/print-instantiation-declarations.py
index b221cf01cf97ea0..a1f582c516c9b9d 100644
--- a/flang/include/flang/Lower/Support/print-instantiation-declarations.py
+++ b/flang/include/flang/Lower/Support/print-instantiation-declarations.py
@@ -110,7 +110,6 @@ def __init__(self, category, kind):
 
     def to_string(self):
         return f"Fortran::evaluate::Type<{self.category.to_string()}, {self.kind}>"
-        )
 
 
 ArithCategories = [Complex, Integer, Real, Unsigned]