public static Stella_Object walkEqualityTree(Cons tree, Object [] MV_returnarray) {
    { Stella_Object arg1 = null;
      Stella_Object arg2 = null;
      StandardObject type1 = null;
      StandardObject type2 = null;

      { Object [] caller_MV_returnarray = new Object[1];

        arg1 = Stella_Object.walkExpressionTree(tree.rest.value, Stella.SGT_STELLA_UNKNOWN, ((Symbol)(tree.value)), true, caller_MV_returnarray);
        type1 = ((StandardObject)(caller_MV_returnarray[0]));
      }
      { Object [] caller_MV_returnarray = new Object[1];

        arg2 = Stella_Object.walkExpressionTree(tree.rest.rest.value, Stella.SGT_STELLA_UNKNOWN, ((Symbol)(tree.value)), true, caller_MV_returnarray);
        type2 = ((StandardObject)(caller_MV_returnarray[0]));
      }
      tree.secondSetter(arg1);
      tree.thirdSetter(arg2);
      if (Stella_Object.vrletExpressionP(arg1)) {
        return (Stella_Object.walkATree(Cons.percolateOutVrletExpression(tree, ((Cons)(arg1)), Stella.SGT_STELLA_BOOLEAN, new Object[1]), MV_returnarray));
      }
      if (Stella_Object.vrletExpressionP(arg2)) {
        return (Stella_Object.walkATree(Cons.percolateOutVrletExpression(tree, ((Cons)(arg2)), Stella.SGT_STELLA_BOOLEAN, new Object[1]), MV_returnarray));
      }
      type1 = Surrogate.canonicalType(StandardObject.typeSpecToBaseType(type1));
      type2 = Surrogate.canonicalType(StandardObject.typeSpecToBaseType(type2));
      if (!((type1 == Stella.SGT_STELLA_UNKNOWN) ||
          ((type2 == Stella.SGT_STELLA_UNKNOWN) ||
           (Surrogate.subtypeOfP(((Surrogate)(type1)), ((Surrogate)(type2))) ||
            (Surrogate.subtypeOfP(((Surrogate)(type2)), ((Surrogate)(type1))) ||
             ((Surrogate.subtypeOfP(((Surrogate)(type1)), Stella.SGT_STELLA_NUMBER) &&
          Surrogate.subtypeOfP(((Surrogate)(type2)), Stella.SGT_STELLA_NUMBER)) ||
              (Surrogate.subtypeOfP(((Surrogate)(type1)).typeToWrappedType(), ((Surrogate)(type2))) ||
               Surrogate.subtypeOfP(((Surrogate)(type2)).typeToWrappedType(), ((Surrogate)(type1)))))))))) {
        { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

          try {
            Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
            Stella.signalTranslationWarning();
            if (!(Stella.suppressWarningsP())) {
              Stella.printErrorContext(">> WARNING: ", Stella.STANDARD_WARNING);
              {
                Stella.STANDARD_WARNING.nativeStream.println();
                Stella.STANDARD_WARNING.nativeStream.println(" This equality test will always fail due to disjoint argument types:");
                Stella.STANDARD_WARNING.nativeStream.println("    `" + Stella_Object.deUglifyParseTree(tree) + "'.");
              }
;
            }

          } finally {
            Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
          }
        }
      }
      { GeneralizedSymbol testValue000 = ((GeneralizedSymbol)(tree.value));

        if ((testValue000 == Stella.SYM_STELLA_EQp) ||
            (testValue000 == Stella.SYM_STELLA_e)) {
          tree.firstSetter(Stella.SYM_STELLA_EQp);
          tree.secondSetter(Stella_Object.sysTree(tree.rest.value, type1, new Object[1]));
          tree.thirdSetter(Stella_Object.sysTree(tree.rest.rest.value, type2, new Object[1]));
          { Stella_Object _return_temp = tree;

            MV_returnarray[0] = Stella.SGT_STELLA_BOOLEAN;
            return (_return_temp);
          }
        }
        else if (testValue000 == Stella.SYM_STELLA_EQLp) {
          return (Cons.finishWalkingEqlTree(tree, ((Surrogate)(type1)), ((Surrogate)(type2)), MV_returnarray));
        }
        else {
          { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

            stream000.nativeStream.print("`" + testValue000 + "' is not a valid case option");
            throw ((StellaException)(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
          }
        }
      }
    }
  }