public static Stella_Object evaluateConsTree(Cons tree, Object [] MV_returnarray) {
    { Object old$Evaluationparenttree$000 = Stella.$EVALUATIONPARENTTREE$.get();
      Object old$Evaluationtree$000 = Stella.$EVALUATIONTREE$.get();

      try {
        Native.setSpecial(Stella.$EVALUATIONPARENTTREE$, ((Stella_Object)(Stella.$EVALUATIONTREE$.get())));
        Native.setSpecial(Stella.$EVALUATIONTREE$, tree);
        { Stella_Object operatorname = tree.value;
          Cons arguments = tree.rest;
          MethodSlot operator = null;

          if (Surrogate.subtypeOfSymbolP(Stella_Object.safePrimaryType(operatorname))) {
            { Symbol operatorname000 = ((Symbol)(operatorname));

              if (operatorname000 == Stella.SYM_STELLA_QUOTE) {
                if (arguments.length() == 1) {
                  { Stella_Object _return_temp = arguments.value;

                    MV_returnarray[0] = arguments.value.primaryType();
                    return (_return_temp);
                  }
                }
                { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

                  stream000.nativeStream.print("While evaluating '" + ((Stella_Object)(Stella.$EVALUATIONTREE$.get())));
                  if (((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())) != null) {
                    {
                      stream000.nativeStream.println();
                      stream000.nativeStream.print("' inside '" + ((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())));
                    }
;
                  }
                  stream000.nativeStream.println("':");
                  stream000.nativeStream.print("Illegal QUOTE expression");
                  throw ((EvaluationException)(EvaluationException.newEvaluationException(stream000.theStringReader()).fillInStackTrace()));
                }
              }
              else if (operatorname000 == Stella.SYM_STELLA_BQUOTE) {
                return (Cons.evaluateBquoteTree(tree, MV_returnarray));
              }
              else if (operatorname000 == Stella.SYM_STELLA_CONS) {
                { Stella_Object arg1 = Stella_Object.evaluateArgumentTree(arguments.value, true, new Object[1]);
                  Stella_Object arg2 = Stella_Object.evaluateArgumentTree(arguments.rest.value, true, new Object[1]);

                  if (Stella_Object.consP(arg2) &&
                      (arguments.rest.rest == Stella.NIL)) {
                    { Stella_Object _return_temp = Cons.cons(arg1, ((Cons)(arg2)));

                      MV_returnarray[0] = Stella.SGT_STELLA_CONS;
                      return (_return_temp);
                    }
                  }
                  { OutputStringStream stream001 = OutputStringStream.newOutputStringStream();

                    stream001.nativeStream.print("While evaluating '" + ((Stella_Object)(Stella.$EVALUATIONTREE$.get())));
                    if (((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())) != null) {
                      {
                        stream001.nativeStream.println();
                        stream001.nativeStream.print("' inside '" + ((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())));
                      }
;
                    }
                    stream001.nativeStream.println("':");
                    stream001.nativeStream.print("Illegal CONS expression");
                    throw ((EvaluationException)(EvaluationException.newEvaluationException(stream001.theStringReader()).fillInStackTrace()));
                  }
                }
              }
              else if (operatorname000 == Stella.SYM_STELLA_APPEND) {
                { Stella_Object arg1 = Stella_Object.evaluateArgumentTree(arguments.value, true, new Object[1]);
                  Stella_Object arg2 = Stella_Object.evaluateArgumentTree(arguments.rest.value, true, new Object[1]);

                  if (Stella_Object.consP(arg1) &&
                      (Stella_Object.consP(arg2) &&
                       (arguments.rest.rest == Stella.NIL))) {
                    { Stella_Object _return_temp = Cons.append(((Cons)(arg1)), ((Cons)(arg2)));

                      MV_returnarray[0] = Stella.SGT_STELLA_CONS;
                      return (_return_temp);
                    }
                  }
                  { OutputStringStream stream002 = OutputStringStream.newOutputStringStream();

                    stream002.nativeStream.print("While evaluating '" + ((Stella_Object)(Stella.$EVALUATIONTREE$.get())));
                    if (((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())) != null) {
                      {
                        stream002.nativeStream.println();
                        stream002.nativeStream.print("' inside '" + ((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())));
                      }
;
                    }
                    stream002.nativeStream.println("':");
                    stream002.nativeStream.print("Illegal APPEND expression");
                    throw ((EvaluationException)(EvaluationException.newEvaluationException(stream002.theStringReader()).fillInStackTrace()));
                  }
                }
              }
              else if (operatorname000 == Stella.SYM_STELLA_PROGN) {
                { Stella_Object arg = null;
                  Cons iter000 = arguments;

                  for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                    arg = iter000.value;
                    Stella_Object.evaluate(arg);
                  }
                }
                { Stella_Object _return_temp = null;

                  MV_returnarray[0] = Stella.SGT_STELLA_VOID;
                  return (_return_temp);
                }
              }
              else {
                { boolean testValue000 = false;

                  { 
                    operator = Symbol.lookupCommand(operatorname000);
                    testValue000 = operator != null;
                  }
                  testValue000 = !testValue000;
                  if (testValue000) {
                    { OutputStringStream stream003 = OutputStringStream.newOutputStringStream();

                      stream003.nativeStream.print("While evaluating '" + ((Stella_Object)(Stella.$EVALUATIONTREE$.get())));
                      if (((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())) != null) {
                        {
                          stream003.nativeStream.println();
                          stream003.nativeStream.print("' inside '" + ((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())));
                        }
;
                      }
                      stream003.nativeStream.println("':");
                      stream003.nativeStream.print("Undefined operator: `" + operatorname000 + "'");
                      throw ((EvaluationException)(EvaluationException.newEvaluationException(stream003.theStringReader()).fillInStackTrace()));
                    }
                  }
                }
              }
            }
          }
          else {
            { OutputStringStream stream004 = OutputStringStream.newOutputStringStream();

              stream004.nativeStream.print("While evaluating '" + ((Stella_Object)(Stella.$EVALUATIONTREE$.get())));
              if (((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())) != null) {
                {
                  stream004.nativeStream.println();
                  stream004.nativeStream.print("' inside '" + ((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())));
                }
;
              }
              stream004.nativeStream.println("':");
              stream004.nativeStream.print("Illegal operator: `" + operatorname + "'");
              throw ((EvaluationException)(EvaluationException.newEvaluationException(stream004.theStringReader()).fillInStackTrace()));
            }
          }
          { java.lang.reflect.Method evaluatorwrappercode = ((FunctionCodeWrapper)(KeyValueList.dynamicSlotValue(operator.dynamicSlots, Stella.SYM_STELLA_EVALUATOR_WRAPPER_CODE, Stella.NULL_FUNCTION_CODE_WRAPPER))).wrapperValue;
            boolean evaluateargsP = operator.methodEvaluateArgumentsP();
            boolean variableargsP = ((BooleanWrapper)(KeyValueList.dynamicSlotValue(operator.dynamicSlots, Stella.SYM_STELLA_METHOD_VARIABLE_ARGUMENTSp, Stella.FALSE_WRAPPER))).wrapperValue;
            List parametertypes = operator.methodParameterTypeSpecifiers();
            int nofparameters = parametertypes.length();
            int nofargs = arguments.length();
            int minargs = (variableargsP ? (nofparameters - 1) : nofparameters);
            int maxargs = (variableargsP ? ((int)(Stella.NULL_INTEGER)) : nofparameters);
            Cons unevaluatedargs = arguments;
            Stella_Object evaluatedarg = null;
            StandardObject evaluatedargtype = null;
            int argindex = 0;
            Surrogate returntype = operator.type();
            Stella_Object result = null;

            if ((nofargs < minargs) ||
                ((maxargs != Stella.NULL_INTEGER) &&
                 (nofargs > maxargs))) {
              { String minstring = Native.integerToString(((long)(minargs)));
                String maxstring = "";

                if (maxargs == Stella.NULL_INTEGER) {
                  maxstring = "+";
                }
                else if (maxargs > minargs) {
                  maxstring = Native.stringConcatenate("-", Native.integerToString(((long)(maxargs))));
                }
                { OutputStringStream stream005 = OutputStringStream.newOutputStringStream();

                  stream005.nativeStream.print("While evaluating '" + ((Stella_Object)(Stella.$EVALUATIONTREE$.get())));
                  if (((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())) != null) {
                    {
                      stream005.nativeStream.println();
                      stream005.nativeStream.print("' inside '" + ((Stella_Object)(Stella.$EVALUATIONPARENTTREE$.get())));
                    }
;
                  }
                  stream005.nativeStream.println("':");
                  stream005.nativeStream.print("Wrong number of arguments.  Expected `" + minstring + "'`" + maxstring + "' but got `" + nofargs + "'");
                  throw ((EvaluationException)(EvaluationException.newEvaluationException(stream005.theStringReader()).fillInStackTrace()));
                }
              }
            }
            while (!(unevaluatedargs == Stella.NIL)) {
              { Object [] caller_MV_returnarray = new Object[1];

                evaluatedarg = Stella_Object.evaluateArgumentTree(unevaluatedargs.value, evaluateargsP, caller_MV_returnarray);
                evaluatedargtype = ((StandardObject)(caller_MV_returnarray[0]));
              }
              { Object [] caller_MV_returnarray = new Object[1];

                evaluatedarg = Stella_Object.coerceEvaluatedTree(evaluatedarg, unevaluatedargs.value, evaluatedargtype, ((argindex >= minargs) ? MethodSlot.variableArgumentsType(operator) : ((StandardObject)(parametertypes.nth(argindex)))), evaluateargsP, caller_MV_returnarray);
                evaluatedargtype = ((StandardObject)(caller_MV_returnarray[0]));
              }
              unevaluatedargs.value = evaluatedarg;
              unevaluatedargs = unevaluatedargs.rest;
              argindex = argindex + 1;
            }
            if (evaluatorwrappercode != null) {
              if (StandardObject.voidP(returntype)) {
                edu.isi.stella.javalib.Native.funcall(evaluatorwrappercode, null, new java.lang.Object [] {arguments});
              }
              else {
                result = ((Stella_Object)(edu.isi.stella.javalib.Native.funcall(evaluatorwrappercode, null, new java.lang.Object [] {arguments})));
              }
            }
            else {
              if (StandardObject.voidP(returntype)) {
                Stella.apply(operator.functionCode, arguments);
              }
              else {
                result = Stella.apply(operator.functionCode, arguments);
              }
            }
            if (result != null) {
              returntype = result.primaryType();
            }
            { Stella_Object _return_temp = result;

              MV_returnarray[0] = returntype;
              return (_return_temp);
            }
          }
        }

      } finally {
        Stella.$EVALUATIONTREE$.set(old$Evaluationtree$000);
        Stella.$EVALUATIONPARENTTREE$.set(old$Evaluationparenttree$000);
      }
    }
  }