public static Stella_Object walkArithmeticTree(Cons tree, Object [] MV_returnarray) {
    { Stella_Object operator = tree.value;
      Cons operands = tree.rest;
      int nofoperands = operands.length();
      Stella_Object operand = null;
      StandardObject operandtype = null;
      Surrogate returntype = Stella.SGT_STELLA_INTEGER;

      switch (nofoperands) {
        case 0: 
          { GeneralizedSymbol testValue000 = ((GeneralizedSymbol)(operator));

            if (testValue000 == Stella.SYM_STELLA_i) {
              { Stella_Object _return_temp = IntegerWrapper.wrapInteger(0);

                MV_returnarray[0] = Stella.SGT_STELLA_INTEGER;
                return (_return_temp);
              }
            }
            else if (testValue000 == Stella.SYM_STELLA_$) {
              { Stella_Object _return_temp = IntegerWrapper.wrapInteger(1);

                MV_returnarray[0] = Stella.SGT_STELLA_INTEGER;
                return (_return_temp);
              }
            }
            else {
              Cons.badArgumentCountP(tree, 1);
              { Cons value000 = null;
                StandardObject value001 = null;

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

                  value000 = Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_NUMBER, caller_MV_returnarray);
                  value001 = ((StandardObject)(caller_MV_returnarray[0]));
                }
                { Stella_Object _return_temp = value000;

                  MV_returnarray[0] = ((Surrogate)(value001));
                  return (_return_temp);
                }
              }
            }
          }
        case 1: 
          { GeneralizedSymbol testValue001 = ((GeneralizedSymbol)(operator));

            if ((testValue001 == Stella.SYM_STELLA_i) ||
                (testValue001 == Stella.SYM_STELLA_$)) {
              { Stella_Object value002 = null;
                StandardObject value003 = null;

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

                  value002 = Stella_Object.walkExpressionTree(operands.value, Stella.SGT_STELLA_NUMBER, ((Symbol)(operator)), false, caller_MV_returnarray);
                  value003 = ((StandardObject)(caller_MV_returnarray[0]));
                }
                { Stella_Object _return_temp = value002;

                  MV_returnarray[0] = ((Surrogate)(value003));
                  return (_return_temp);
                }
              }
            }
            else if ((testValue001 == Stella.SYM_STELLA__) ||
                (testValue001 == Stella.SYM_STELLA_s)) {
              operands.rest = Cons.cons(operands.value, Stella.NIL);
              operands.firstSetter(((operator == Stella.SYM_STELLA__) ? IntegerWrapper.wrapInteger(0) : IntegerWrapper.wrapInteger(1)));
            }
            else {
              { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

                stream000.nativeStream.print("`" + testValue001 + "' is not a valid case option");
                throw ((StellaException)(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
              }
            }
          }
        break;
        default:
        break;
      }
      { ConsIterator it = operands.allocateIterator();

        while (it.nextP()) {
          { Object [] caller_MV_returnarray = new Object[1];

            operand = Stella_Object.walkExpressionTree(it.value, Stella.SGT_STELLA_NUMBER, ((Symbol)(operator)), false, caller_MV_returnarray);
            operandtype = ((StandardObject)(caller_MV_returnarray[0]));
          }
          returntype = Surrogate.moreGeneralNumericType(returntype, StandardObject.typeSpecToBaseType(operandtype));
          it.valueSetter(operand);
        }
      }
      if ((operator == Stella.SYM_STELLA_s) &&
          ((returntype == Stella.SGT_STELLA_INTEGER) ||
           (returntype == Stella.SGT_STELLA_LONG_INTEGER))) {
        if (Stella_Object.wrapperP(operands.value)) {
          operands.firstSetter(FloatWrapper.wrapFloat(Stella_Object.coerceToFloat(operands.value)));
        }
        else if (Stella_Object.wrapperP(operands.rest.value)) {
          operands.secondSetter(FloatWrapper.wrapFloat(Stella_Object.coerceToFloat(operands.rest.value)));
        }
        else {
          operands = Cons.cons(Cons.list$(Cons.cons(Stella.SYM_STELLA_CAST, Cons.cons(operands.value, Cons.cons(Cons.cons(Stella.SGT_STELLA_FLOAT, Stella.NIL), Stella.NIL)))), operands.rest.concatenate(Stella.NIL, Stella.NIL));
          nofoperands = nofoperands + 1;
        }
        returntype = Stella.SGT_STELLA_FLOAT;
      }
      if ((nofoperands > 2) &&
          (!(((Keyword)(Stella.$TRANSLATOROUTPUTLANGUAGE$.get())) == Stella.KWD_COMMON_LISP))) {
        { Cons value004 = null;
          StandardObject value005 = null;

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

            value004 = Stella_Object.sysTree(Symbol.yieldNestedArithmeticOperatorCallTree(((Symbol)(operator)), operands), returntype, caller_MV_returnarray);
            value005 = ((StandardObject)(caller_MV_returnarray[0]));
          }
          { Stella_Object _return_temp = value004;

            MV_returnarray[0] = ((Surrogate)(value005));
            return (_return_temp);
          }
        }
      }
      else {
        { Cons value006 = null;
          StandardObject value007 = null;

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

            value006 = Stella_Object.sysTree(Symbol.yieldArithmeticOperatorCallTree(((Symbol)(operator)), operands), returntype, caller_MV_returnarray);
            value007 = ((StandardObject)(caller_MV_returnarray[0]));
          }
          { Stella_Object _return_temp = value006;

            MV_returnarray[0] = ((Surrogate)(value007));
            return (_return_temp);
          }
        }
      }
    }
  }