public static Cons walkCaseTree(Cons tree, Object [] MV_returnarray) {
    { boolean testValue000 = false;

      testValue000 = tree.length() >= 3;
      if (testValue000) {
        { boolean alwaysP000 = true;

          { Stella_Object clause = null;
            Cons iter000 = tree.rest.rest;

            loop000 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
              clause = iter000.value;
              if (!Stella_Object.consP(clause)) {
                alwaysP000 = false;
                break loop000;
              }
            }
          }
          testValue000 = alwaysP000;
        }
      }
      testValue000 = !testValue000;
      if (testValue000) {
        { 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(" Illegal `case' statement: `" + Stella_Object.deUglifyParseTree(tree) + "'.");
              }
;
            }

          } finally {
            Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
          }
        }
        return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
      }
    }
    { Cons clauses = ((Cons)(tree.rest.rest));
      Stella_Object firsttesttree = (Stella_Object.consP(((Cons)(clauses.value)).value) ? ((Cons)(((Cons)(clauses.value)).value)).value : ((Cons)(clauses.value)).value);
      Surrogate caseconstanttype = Stella.SGT_STELLA_UNKNOWN;

      { Surrogate testValue001 = Stella_Object.safePrimaryType(firsttesttree);

        if (Surrogate.subtypeOfSymbolP(testValue001)) {
          { Symbol firsttesttree000 = ((Symbol)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_GENERALIZED_SYMBOL;
          }
        }
        else if (Surrogate.subtypeOfSurrogateP(testValue001)) {
          { Surrogate firsttesttree000 = ((Surrogate)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_GENERALIZED_SYMBOL;
          }
        }
        else if (Surrogate.subtypeOfKeywordP(testValue001)) {
          { Keyword firsttesttree000 = ((Keyword)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_GENERALIZED_SYMBOL;
          }
        }
        else if (Surrogate.subtypeOfStringP(testValue001)) {
          { StringWrapper firsttesttree000 = ((StringWrapper)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_STRING;
          }
        }
        else if (Surrogate.subtypeOfCharacterP(testValue001)) {
          { CharacterWrapper firsttesttree000 = ((CharacterWrapper)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_CHARACTER;
          }
        }
        else if (Surrogate.subtypeOfIntegerP(testValue001)) {
          { IntegerWrapper firsttesttree000 = ((IntegerWrapper)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_INTEGER;
          }
        }
        else if (Surrogate.subtypeOfLongIntegerP(testValue001)) {
          { LongIntegerWrapper firsttesttree000 = ((LongIntegerWrapper)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_LONG_INTEGER;
          }
        }
        else if (Surrogate.subtypeOfFloatP(testValue001)) {
          { FloatWrapper firsttesttree000 = ((FloatWrapper)(firsttesttree));

            caseconstanttype = Stella.SGT_STELLA_FLOAT;
          }
        }
        else {
          { 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(" `case' statement contains illegal constant of type `" + firsttesttree.primaryType() + "'");
                  Stella.STANDARD_ERROR.nativeStream.println("    `" + Stella_Object.deUglifyParseTree(tree) + "'.");
                }
;
              }

            } finally {
              Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
            }
          }
          return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
        }
      }
      tree.secondSetter(Stella_Object.walkExpressionTree(tree.rest.value, caseconstanttype, Stella.SYM_STELLA_CASE, true, new Object[1]));
      if (Stella_Object.vrletExpressionP(tree.rest.value)) {
        return (Cons.percolateOutVrletExpression(tree, ((Cons)(tree.rest.value)), caseconstanttype, MV_returnarray));
      }
      if ((caseconstanttype == Stella.SGT_STELLA_GENERALIZED_SYMBOL) &&
          Stella.useHardcodedSymbolsP()) {
        return (Cons.walkHardcodedSymbolCaseTree(tree, MV_returnarray));
      }
      if (!((caseconstanttype == Stella.SGT_STELLA_INTEGER) ||
          ((caseconstanttype == Stella.SGT_STELLA_LONG_INTEGER) ||
           (caseconstanttype == Stella.SGT_STELLA_CHARACTER)))) {
        return (Cons.walkNonBuiltInCaseTree(tree, ((caseconstanttype == Stella.SGT_STELLA_STRING) ? Stella.SYM_STELLA_STRING_EQLp : Stella.SYM_STELLA_EQLp), MV_returnarray));
      }
      if (!(((Keyword)(Stella.$TRANSLATOROUTPUTLANGUAGE$.get())) == Stella.KWD_COMMON_LISP)) {
        tree = Cons.attachUnhandledCaseErrorClause(tree, tree.rest.value);
      }
      { Cons cursor = tree.rest.rest;
        Cons conditiontree = null;

        while (!(cursor == Stella.NIL)) {
          conditiontree = ((Cons)(cursor.value));
          if (!(conditiontree.value == Stella.SYM_STELLA_OTHERWISE)) {
            conditiontree.firstSetter((Stella_Object.consP(conditiontree.value) ? Cons.walkListOfTrees(((Cons)(conditiontree.value))) : Stella_Object.walkATree(conditiontree.value, new Object[1])));
          }
          conditiontree.rest = Cons.walkListOfStatements(conditiontree.rest);
          cursor = cursor.rest;
        }
        { Cons _return_temp = tree;

          MV_returnarray[0] = Stella.SGT_STELLA_VOID;
          return (_return_temp);
        }
      }
    }
  }