public static Stella_Object helpClTranslateATree(Stella_Object tree) {
    if (tree == null) {
      return (tree);
    }
    if (Stella_Object.safePrimaryType(tree) == Stella.SGT_STELLA_CONS) {
      { Cons tree000 = ((Cons)(tree));

        if (tree000 == Stella.NIL) {
          return (tree000);
        }
        { GeneralizedSymbol testValue000 = ((GeneralizedSymbol)(tree000.value));

          if (testValue000 == Stella.SYM_STELLA_VOID_SYS) {
            return (Cons.clTranslateVoidSys(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_TYPED_SYS) {
            return (Cons.clTranslateTypedSys(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_BAD_SYS) {
            return (Cons.clTranslateBadSys(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SETQ) {
            return (Cons.clTranslateSetqTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_SLOT_VALUE) {
            return (Cons.clTranslateFixedSlotValueTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_SLOT_VALUE_SETTER) {
            return (Cons.clTranslateFixedSlotValueSetterTree(tree000));
          }
          else if ((testValue000 == Stella.SYM_STELLA_SYS_CALL_METHOD) ||
              (testValue000 == Stella.SYM_STELLA_SYS_CALL_FUNCTION)) {
            return (Cons.clTranslateCallMethodTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_PROGN) {
            tree000.value = Stella.internCommonLispSymbol("PROGN");
            tree000.rest = Cons.clTranslateListOfTrees(tree000.rest);
            return (tree000);
          }
          else if (testValue000 == Stella.SYM_STELLA_WITH_PROCESS_LOCK) {
            tree000.value = Symbol.clTranslateGlobalSymbol(Stella.SYM_STELLA_WITH_PROCESS_LOCK);
            tree000.secondSetter(Stella_Object.clTranslateATree(tree000.rest.value));
            tree000.rest.rest = Cons.clTranslateListOfTrees(tree000.rest.rest);
            return (tree000);
          }
          else if (testValue000 == Stella.SYM_STELLA_LOOP) {
            { Object old$NeedexplicitreturnP$000 = Stella.$NEEDEXPLICITRETURNp$.get();

              try {
                Native.setBooleanSpecial(Stella.$NEEDEXPLICITRETURNp$, true);
                tree000.value = Stella.internCommonLispSymbol("LOOP");
                tree000.rest = Cons.maybeWrapWithContinueLabel(Cons.clTranslateListOfTrees(tree000.rest));
                return (tree000);

              } finally {
                Stella.$NEEDEXPLICITRETURNp$.set(old$NeedexplicitreturnP$000);
              }
            }
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_FOREACH) {
            { Object old$NeedexplicitreturnP$001 = Stella.$NEEDEXPLICITRETURNp$.get();

              try {
                Native.setBooleanSpecial(Stella.$NEEDEXPLICITRETURNp$, true);
                return (Cons.clTranslateForeachTree(tree000));

              } finally {
                Stella.$NEEDEXPLICITRETURNp$.set(old$NeedexplicitreturnP$001);
              }
            }
          }
          else if (testValue000 == Stella.SYM_STELLA_LET) {
            return (Cons.clTranslateLetTree(tree000, false));
          }
          else if (testValue000 == Stella.SYM_STELLA_STARTUP_TIME_PROGN) {
            { Object old$NeedexplicitreturnP$002 = Stella.$NEEDEXPLICITRETURNp$.get();

              try {
                Native.setBooleanSpecial(Stella.$NEEDEXPLICITRETURNp$, true);
                return (Cons.clTranslateStartupTimePrognTree(tree000));

              } finally {
                Stella.$NEEDEXPLICITRETURNp$.set(old$NeedexplicitreturnP$002);
              }
            }
          }
          else if (testValue000 == Stella.SYM_STELLA_SPECIAL) {
            return (Cons.clTranslateSpecialTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_UNWIND_PROTECT) {
            return (Cons.clTranslateUnwindProtectTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_HANDLER_CASE) {
            return (Cons.clTranslateHandlerCaseTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_HANDLE_EXCEPTION) {
            return (Cons.clTranslateHandleExceptionTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_SIGNAL) {
            return (Cons.clTranslateSignalTree(tree000));
          }
          else if ((testValue000 == Stella.SYM_STELLA_CAST) ||
              (testValue000 == Stella.SYM_STELLA_SAFE_CAST)) {
            return (Cons.clTranslateCastTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_RETURN) {
            return (Cons.clTranslateReturnTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_BREAK) {
            tree000.firstSetter(Stella.internCommonLispSymbol("RETURN"));
            return (tree000);
          }
          else if (testValue000 == Stella.SYM_STELLA_CONTINUE) {
            return (Cons.list$(Cons.cons(Stella.internCommonLispSymbol("GO"), Cons.cons(Stella.KWD_CONTINUE, Cons.cons(Stella.NIL, Stella.NIL)))));
          }
          else if (testValue000 == Stella.SYM_STELLA_WHILE) {
            { Object old$NeedexplicitreturnP$003 = Stella.$NEEDEXPLICITRETURNp$.get();

              try {
                Native.setBooleanSpecial(Stella.$NEEDEXPLICITRETURNp$, true);
                return (Cons.clTranslateWhileTree(tree000));

              } finally {
                Stella.$NEEDEXPLICITRETURNp$.set(old$NeedexplicitreturnP$003);
              }
            }
          }
          else if ((testValue000 == Stella.SYM_STELLA_IF) ||
              ((testValue000 == Stella.SYM_STELLA_CHOOSE) ||
               ((testValue000 == Stella.SYM_STELLA_WHEN) ||
                (testValue000 == Stella.SYM_STELLA_UNLESS)))) {
            return (Cons.clTranslateConditionalTree(tree000));
          }
          else if ((testValue000 == Stella.SYM_STELLA_AND) ||
              ((testValue000 == Stella.SYM_STELLA_OR) ||
               (testValue000 == Stella.SYM_STELLA_NOT))) {
            return (Cons.clTranslateBooleanTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_COND) {
            return (Cons.clTranslateCondTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_CASE) {
            return (Cons.clTranslateCaseTree(tree000));
          }
          else if ((testValue000 == Stella.SYM_STELLA_EQp) ||
              ((testValue000 == Stella.SYM_STELLA_g) ||
               ((testValue000 == Stella.SYM_STELLA_ge) ||
                ((testValue000 == Stella.SYM_STELLA_l) ||
                 (testValue000 == Stella.SYM_STELLA_le))))) {
            return (Cons.clTranslateOperatorTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_MAKE) {
            return (Cons.clTranslateMakeTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_NEW) {
            return (Cons.clTranslateNewTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_MV_SETQ) {
            tree000.firstSetter(Stella.internCommonLispSymbol("MULTIPLE-VALUE-SETQ"));
            tree000.secondSetter(Cons.clTranslateListOfTrees(((Cons)(tree000.rest.value))));
            tree000.thirdSetter(Stella_Object.clTranslateATree(tree000.rest.rest.value));
            return (tree000);
          }
          else if (testValue000 == Stella.SYM_STELLA_QUOTE) {
            tree000.firstSetter(Stella.internCommonLispSymbol("QUOTE"));
            return (tree000);
          }
          else if ((testValue000 == Stella.SYM_STELLA_SYS_CALL_FUNCTION_CODE) ||
              (testValue000 == Stella.SYM_STELLA_SYS_CALL_METHOD_CODE)) {
            return (Cons.clTranslateCallFunctionCodeTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_SYS_INLINE_CALL) {
            return (Cons.clTranslateInlineCallTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_THE_CODE) {
            return (Cons.clTranslateTheCodeTree(tree000));
          }
          else if ((testValue000 == Stella.SYM_STELLA_PRINT_STREAM) ||
              (testValue000 == Stella.SYM_STELLA_PRINT_NATIVE_STREAM)) {
            return (Cons.clTranslatePrintStreamTree(tree000));
          }
          else if (testValue000 == Stella.SYM_STELLA_VERBATIM) {
            return (Cons.clTranslateVerbatimTree(tree000));
          }
          else if ((testValue000 == Stella.SYM_STELLA_INLINE) ||
              (testValue000 == Stella.SYM_STELLA_IGNORE)) {
            return (Cons.clTranslateInlineTree(tree000));
          }
          else {
            { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

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