public static Stella_Object helpWalkATree(Stella_Object tree, Object [] MV_returnarray) {
    if (tree == null) {
      { Stella_Object _return_temp = null;

        MV_returnarray[0] = Stella.SGT_STELLA_UNKNOWN;
        return (_return_temp);
      }
    }
    else {
      if (Stella_Object.safePrimaryType(tree) == Stella.SGT_STELLA_CONS) {
        { Cons tree000 = ((Cons)(tree));

          if (tree000 == Stella.NIL) {
            { Stella_Object _return_temp = Stella.NIL;

              MV_returnarray[0] = Stella.SGT_STELLA_CONS;
              return (_return_temp);
            }
          }
          if (Stella_Object.consP(tree000.value)) {
            { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

              try {
                Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                Stella.signalTranslationError();
                if (!(Stella.suppressWarningsP())) {
                  Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
                  {
                    Stella.STANDARD_ERROR.nativeStream.println();
                    Stella.STANDARD_ERROR.nativeStream.println(" Unimplemented or illegal parse tree: `" + Stella_Object.deUglifyParseTree(tree000) + "'.");
                  }
;
                }

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
              }
            }
            { Stella_Object _return_temp = tree000;

              MV_returnarray[0] = Stella.SGT_STELLA_VOID;
              return (_return_temp);
            }
          }
          if (!(Stella_Object.consP(tree000.rest))) {
            { Object old$PrintreadablyP$001 = Stella.$PRINTREADABLYp$.get();

              try {
                Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                Stella.signalTranslationError();
                if (!(Stella.suppressWarningsP())) {
                  Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
                  {
                    Stella.STANDARD_ERROR.nativeStream.println();
                    Stella.STANDARD_ERROR.nativeStream.println(" Illegal dotted pair or list*.");
                  }
;
                }

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
              }
            }
            { Stella_Object _return_temp = tree000;

              MV_returnarray[0] = Stella.SGT_STELLA_VOID;
              return (_return_temp);
            }
          }
          { GeneralizedSymbol testValue000 = ((GeneralizedSymbol)(tree000.value));

            if (testValue000 == Stella.SYM_STELLA_VOID_SYS) {
              { Stella_Object _return_temp = tree000;

                MV_returnarray[0] = Stella.SGT_STELLA_VOID;
                return (_return_temp);
              }
            }
            else if (testValue000 == Stella.SYM_STELLA_TYPED_SYS) {
              { Stella_Object _return_temp = tree000;

                MV_returnarray[0] = ((StandardObject)(tree000.rest.rest.value));
                return (_return_temp);
              }
            }
            else if (testValue000 == Stella.SYM_STELLA_SYS_FOREACH) {
              { Stella_Object _return_temp = tree000;

                MV_returnarray[0] = Stella.SGT_STELLA_VOID;
                return (_return_temp);
              }
            }
            else if (testValue000 == Stella.SYM_STELLA_BAD_SYS) {
              { Stella_Object _return_temp = tree000;

                MV_returnarray[0] = ((StandardObject)(tree000.rest.rest.value));
                return (_return_temp);
              }
            }
            else if ((testValue000 == Stella.SYM_STELLA_SETQ) ||
                (testValue000 == Stella.SYM_STELLA_SYS_SET_DEFAULT)) {
              return (Cons.walkSetqTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_SETF) {
              return (Cons.walkSetfTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_SLOT_VALUE) {
              return (Cons.walkSlotValueTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_SLOT_VALUE_SETTER) {
              return (Cons.walkSlotValueSetterTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_AREF) ||
                (testValue000 == Stella.SYM_STELLA_AREF_SETTER)) {
              return (Cons.walkArefTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_PROGN) {
              tree000.rest = Cons.walkListOfStatements(tree000.rest);
              return (Stella_Object.sysTree(tree000, Stella.SGT_STELLA_VOID, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_WITH_PROCESS_LOCK) {
              return (Cons.walkWithProcessLockTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_LOOP) {
              return (Cons.walkLoopTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_LET) {
              return (Cons.walkLetTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_VRLET) {
              { Stella_Object _return_temp = tree000;

                MV_returnarray[0] = Stella.SGT_STELLA_UNKNOWN;
                return (_return_temp);
              }
            }
            else if (testValue000 == Stella.SYM_STELLA_VALUES) {
              return (Cons.walkValuesTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_SPECIAL) ||
                (testValue000 == Stella.SYM_STELLA_SYS_SPECIAL)) {
              return (Cons.walkSpecialTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_CAST) ||
                (testValue000 == Stella.SYM_STELLA_SAFE_CAST)) {
              return (Cons.walkCastTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_RETURN) {
              return (Cons.walkReturnTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_MV_SETQ) {
              return (Cons.walkMvSetqTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_MV_BIND) {
              return (Cons.walkMvBindTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_BREAK) ||
                (testValue000 == Stella.SYM_STELLA_CONTINUE)) {
              return (Cons.walkLoopExitTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_WHILE) {
              return (Cons.walkWhileTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_FOREACH) ||
                ((testValue000 == Stella.SYM_STELLA_EXISTS) ||
                 ((testValue000 == Stella.SYM_STELLA_FORALL) ||
                  ((testValue000 == Stella.SYM_STELLA_SOME) ||
                   ((testValue000 == Stella.SYM_STELLA_SETOF) ||
                    ((testValue000 == Stella.SYM_STELLA_SET_OF) ||
                     (testValue000 == Stella.SYM_STELLA_SELECT))))))) {
              return (Cons.walkForeachTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_IF) ||
                ((testValue000 == Stella.SYM_STELLA_WHEN) ||
                 (testValue000 == Stella.SYM_STELLA_UNLESS))) {
              return (Cons.walkConditionalTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_CHOOSE) {
              return (Cons.walkChooseTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_AND) ||
                ((testValue000 == Stella.SYM_STELLA_OR) ||
                 (testValue000 == Stella.SYM_STELLA_NOT))) {
              return (Cons.walkBooleanTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_COND) {
              return (Cons.walkCondTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_CASE) {
              return (Cons.walkCaseTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_TYPECASE) {
              return (Cons.walkTypecaseTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_EQp) ||
                ((testValue000 == Stella.SYM_STELLA_EQLp) ||
                 (testValue000 == Stella.SYM_STELLA_e))) {
              return (Cons.walkEqualityTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_i) ||
                ((testValue000 == Stella.SYM_STELLA__) ||
                 ((testValue000 == Stella.SYM_STELLA_$) ||
                  (testValue000 == Stella.SYM_STELLA_s)))) {
              { Stella_Object value000 = null;
                Surrogate value001 = null;

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

                  value000 = Cons.walkArithmeticTree(tree000, caller_MV_returnarray);
                  value001 = ((Surrogate)(caller_MV_returnarray[0]));
                }
                { Stella_Object _return_temp = value000;

                  MV_returnarray[0] = value001;
                  return (_return_temp);
                }
              }
            }
            else if (testValue000 == Stella.SYM_STELLA_QUOTE) {
              return (Cons.walkQuotedTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_BQUOTE) {
              return (Cons.walkBquoteTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_PRINT_STREAM) ||
                (testValue000 == Stella.SYM_STELLA_PRINT_NATIVE_STREAM)) {
              return (Cons.walkPrintStreamTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_NEW) ||
                ((testValue000 == Stella.SYM_STELLA_ALLOCATE) ||
                 (testValue000 == Stella.SYM_STELLA_LOCAL_NEW))) {
              return (Cons.walkNewTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_MAKE) {
              return (Cons.walkMakeTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_FUNCALL) ||
                ((testValue000 == Stella.SYM_STELLA_SYS_CALL_FUNCTION_CODE) ||
                 (testValue000 == Stella.SYM_STELLA_SYS_CALL_METHOD_CODE))) {
              return (Cons.walkFuncallTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_THE_CODE) {
              return (Cons.walkTheCodeTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_SIGNAL_EXCEPTION) {
              return (Cons.walkSignalExceptionTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_EXCEPTION_CASE) {
              return (Cons.walkExceptionCaseTree(tree000, MV_returnarray));
            }
            else if ((testValue000 == Stella.SYM_STELLA_UNWIND_PROTECT) ||
                (testValue000 == Stella.SYM_STELLA_SYS_UNWIND_PROTECT)) {
              { Cons value002 = null;
                Surrogate value003 = null;

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

                  value002 = Cons.walkUnwindProtectTree(tree000, caller_MV_returnarray);
                  value003 = ((Surrogate)(caller_MV_returnarray[0]));
                }
                { Stella_Object _return_temp = value002;

                  MV_returnarray[0] = value003;
                  return (_return_temp);
                }
              }
            }
            else if (testValue000 == Stella.SYM_STELLA_VERBATIM) {
              return (Cons.walkVerbatimTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_INLINE) {
              { Stella_Object _return_temp = tree000;

                MV_returnarray[0] = Stella.SGT_STELLA_VOID;
                return (_return_temp);
              }
            }
            else if ((testValue000 == Stella.SYM_STELLA_SYS_SLOT_VALUE) ||
                ((testValue000 == Stella.SYM_STELLA_SYS_SLOT_VALUE_SETTER) ||
                 ((testValue000 == Stella.SYM_STELLA_SYS_CALL_METHOD) ||
                  ((testValue000 == Stella.SYM_STELLA_SYS_CALL_METHOD_SETTER) ||
                   (testValue000 == Stella.SYM_STELLA_SYS_CALL_FUNCTION))))) {
              return (Cons.walkSysCallTree(tree000, MV_returnarray));
            }
            else if (testValue000 == Stella.SYM_STELLA_SYS_NEW) {
              { Stella_Object _return_temp = tree000;

                MV_returnarray[0] = ((StandardObject)(tree000.rest.value));
                return (_return_temp);
              }
            }
            else if ((testValue000 == Stella.SYM_STELLA_DEFCLASS) ||
                ((testValue000 == Stella.SYM_STELLA_DEFMETHOD) ||
                 ((testValue000 == Stella.SYM_STELLA_DEFUN) ||
                  ((testValue000 == Stella.SYM_STELLA_DEFMACRO) ||
                   ((testValue000 == Stella.SYM_STELLA_STARTUP_TIME_PROGN) ||
                    ((testValue000 == Stella.SYM_STELLA_DEFGLOBAL) ||
                     ((testValue000 == Stella.SYM_STELLA_DEFSPECIAL) ||
                      (testValue000 == Stella.SYM_STELLA_DEFCONSTANT)))))))) {
              { Object old$PrintreadablyP$002 = Stella.$PRINTREADABLYp$.get();

                try {
                  Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                  Stella.signalTranslationError();
                  if (!(Stella.suppressWarningsP())) {
                    Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
                    {
                      Stella.STANDARD_ERROR.nativeStream.println();
                      Stella.STANDARD_ERROR.nativeStream.println(" Illegal declaration -- must appear as a top-level statement;");
                      Stella.STANDARD_ERROR.nativeStream.println("   not nested within other statements..");
                    }
;
                  }

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                }
              }
              { Stella_Object _return_temp = null;

                MV_returnarray[0] = Stella.SGT_STELLA_VOID;
                return (_return_temp);
              }
            }
            else {
              if (Stella_Object.symbolP(tree000.value)) {
                return (Cons.walkCallSlotTree(tree000, MV_returnarray));
              }
              else {
                {
                  { Object old$PrintreadablyP$003 = Stella.$PRINTREADABLYp$.get();

                    try {
                      Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                      Stella.signalTranslationError();
                      if (!(Stella.suppressWarningsP())) {
                        Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
                        {
                          Stella.STANDARD_ERROR.nativeStream.println();
                          Stella.STANDARD_ERROR.nativeStream.println(" Illegal expression where method name expected:");
                          Stella.STANDARD_ERROR.nativeStream.println("   `" + tree000.value + "'.");
                        }
;
                      }

                    } finally {
                      Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$003);
                    }
                  }
                  return (Stella_Object.walkDontCallMeTree(tree000, Stella.SGT_STELLA_VOID, MV_returnarray));
                }
              }
            }
          }
        }
      }
      else {
        return (tree.walkAtomicTree(MV_returnarray));
      }
    }
  }