public static Cons walkTheCodeTree(Cons tree, Object [] MV_returnarray) {
    { GeneralizedSymbol testValue000 = ((GeneralizedSymbol)(tree.rest.value));

      if (testValue000 == Stella.KWD_FUNCTION) {
        if (Cons.badArgumentRangeP(tree, 2, 3)) {
          return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_FUNCTION_CODE, MV_returnarray));
        }
        if (tree.rest.rest.value == Stella.SYM_STELLA_MAIN) {
          if ((((Keyword)(Stella.$TRANSLATOROUTPUTLANGUAGE$.get())) == Stella.KWD_CPP) ||
              (((Keyword)(Stella.$TRANSLATOROUTPUTLANGUAGE$.get())) == Stella.KWD_CPP_STANDALONE)) {
            { 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(" Cannot generate a function pointer to `main' in C++.");
                  }
;
                }

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
              }
            }
            return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_FUNCTION_CODE, MV_returnarray));
          }
          else {
            { Object old$PrintreadablyP$001 = 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(" Won't be able to generate a function pointer to `main' in C++.");
                  }
;
                }

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

          MV_returnarray[0] = Stella.SGT_STELLA_FUNCTION_CODE;
          return (_return_temp);
        }
      }
      else if (testValue000 == Stella.KWD_METHOD) {
        if (Cons.badArgumentCountP(tree, 3)) {
          return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_METHOD_CODE, MV_returnarray));
        }
        { Surrogate type = Stella_Object.typify(tree.rest.rest.value);

          tree.thirdSetter(type);
          if (((Stella_Class)(type.surrogateValue)) == null) {
            { 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(" No class defined for the type: `" + Stella_Object.deUglifyParseTree(type) + "'.");
                  }
;
                }

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
              }
            }
          }
          else {
            if ((((Keyword)(Stella.$TRANSLATOROUTPUTLANGUAGE$.get())) == Stella.KWD_CPP) ||
                (((Keyword)(Stella.$TRANSLATOROUTPUTLANGUAGE$.get())) == Stella.KWD_CPP_STANDALONE)) {
              if (Surrogate.subtypeOfP(type, Stella.SGT_STELLA_LITERAL)) {
                { Object old$PrintreadablyP$003 = Stella.$PRINTREADABLYp$.get();

                  try {
                    Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                    Stella.signalTranslationNote();
                    if (!(Stella.suppressWarningsP())) {
                      Stella.printErrorContext(">> NOTE: ", Stella.STANDARD_OUTPUT);
                      {
                        System.out.println();
                        System.out.println(" Cannot have methods on literals in `" + Stella.translatorOutputLanguageName() + "', hence, cannot generate");
                        System.out.println(" a method-code pointer for `" + tree.rest.rest.value + "'.`" + tree.fourth() + "'.");
                      }
;
                    }

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$003);
                  }
                }
                { Stella_Object value000 = null;
                  StandardObject value001 = null;

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

                    value000 = Stella_Object.walkATree(Cons.list$(Cons.cons(Stella.SYM_STELLA_CAST, Cons.cons(Stella.SYM_STELLA_NULL, Cons.cons(Stella.SYM_STELLA_METHOD_CODE, Cons.cons(Stella.NIL, Stella.NIL))))), caller_MV_returnarray);
                    value001 = ((StandardObject)(caller_MV_returnarray[0]));
                  }
                  { Cons _return_temp = ((Cons)(value000));

                    MV_returnarray[0] = value001;
                    return (_return_temp);
                  }
                }
              }
              if (!Surrogate.subtypeOfP(type, Stella.SGT_STELLA_OBJECT)) {
                { Object old$PrintreadablyP$004 = Stella.$PRINTREADABLYp$.get();

                  try {
                    Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                    Stella.signalTranslationNote();
                    if (!(Stella.suppressWarningsP())) {
                      Stella.printErrorContext(">> NOTE: ", Stella.STANDARD_OUTPUT);
                      {
                        System.out.println();
                        System.out.println(" Cannot store a method-code pointer for ");
                        System.out.println(" `" + tree.rest.rest.value + "'.`" + tree.fourth() + "'");
                        System.out.println(" since it is not defined on a subtype of @OBJECT.");
                      }
;
                    }

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$004);
                  }
                }
                { Stella_Object value002 = null;
                  StandardObject value003 = null;

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

                    value002 = Stella_Object.walkATree(Cons.list$(Cons.cons(Stella.SYM_STELLA_CAST, Cons.cons(Stella.SYM_STELLA_NULL, Cons.cons(Stella.SYM_STELLA_METHOD_CODE, Cons.cons(Stella.NIL, Stella.NIL))))), caller_MV_returnarray);
                    value003 = ((StandardObject)(caller_MV_returnarray[0]));
                  }
                  { Cons _return_temp = ((Cons)(value002));

                    MV_returnarray[0] = value003;
                    return (_return_temp);
                  }
                }
              }
            }
            else {
            }
          }
          { Cons _return_temp = tree;

            MV_returnarray[0] = Stella.SGT_STELLA_METHOD_CODE;
            return (_return_temp);
          }
        }
      }
      else {
        { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

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