public static Stella_Object walkCallSlotTree(Cons tree, Object [] MV_returnarray) {
    { Stella_Object slotname = tree.value;
      Stella_Object walkedfirstarg = null;
      StandardObject firstargtype = Stella.SGT_STELLA_VOID;
      Stella_Class firstargclass = null;
      boolean illegalfirstargP = false;
      int previouserrors = ((Integer)(Stella.$TRANSLATIONERRORS$.get())).intValue();
      Slot slot = null;

      if (slotname == Stella.SYM_STELLA_ERROR) {
        Native.setBooleanSpecial(Stella.$FOUNDRETURNp$, true);
      }
      slot = Symbol.lookupFunction(((Symbol)(slotname)));
      if (slot != null) {
        if (((BooleanWrapper)(KeyValueList.dynamicSlotValue(((MethodSlot)(slot)).dynamicSlots, Stella.SYM_STELLA_METHOD_MACROp, Stella.FALSE_WRAPPER))).wrapperValue) {
          return (Cons.walkMacroTree(tree, MV_returnarray));
        }
        else {
          firstargtype = MethodSlot.walkFirstArgumentToFunction(((MethodSlot)(slot)), tree);
        }
      }
      else {
        if (!(tree.rest == Stella.NIL)) {
          { Object [] caller_MV_returnarray = new Object[1];

            walkedfirstarg = Stella_Object.walkExpressionTree(tree.rest.value, Stella.SGT_STELLA_UNKNOWN, ((Symbol)(slotname)), true, caller_MV_returnarray);
            firstargtype = ((StandardObject)(caller_MV_returnarray[0]));
          }
          tree.secondSetter(Stella_Object.coerceATree(walkedfirstarg, firstargtype, firstargtype, new Object[1]));
          if (StandardObject.voidP(firstargtype)) {
            { 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(" First argument in call to `" + Stella_Object.deUglifyParseTree(slotname) + "' returns @VOID.");
                  }
;
                }

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
              }
            }
            return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_UNKNOWN, MV_returnarray));
          }
          firstargclass = StandardObject.typeSpecToClass(firstargtype);
          slot = Stella_Class.lookupSlot(firstargclass, ((Symbol)(slotname)));
        }
      }
      illegalfirstargP = ((Integer)(Stella.$TRANSLATIONERRORS$.get())).intValue() > previouserrors;
      if (Stella_Object.vrletExpressionP(tree.rest.value)) {
        return (Cons.percolateOutVrletExpression(tree, ((Cons)(tree.rest.value)), Stella.SGT_STELLA_UNKNOWN, MV_returnarray));
      }
      if ((slot == null) &&
          StandardObject.subTypeSpecOfP(firstargtype, Stella.SGT_STELLA_ARGUMENT_LIST)) {
        slot = Stella_Class.lookupSlot(((Stella_Class)(Stella.SGT_STELLA_CONS.surrogateValue)), ((Symbol)(slotname)));
      }
      if (slot == null) {
        if (Stella.warnAboutUndefinedMethodsP() &&
            ((!(firstargtype == Stella.SGT_STELLA_UNKNOWN)) &&
             ((firstargclass != null) &&
              firstargclass.abstractP))) {
          return (Cons.walkSlotOnAbstractTypeTree(tree, StandardObject.typeSpecToBaseType(firstargtype), MV_returnarray));
        }
        else {
          { Cons value000 = null;
            Surrogate value001 = null;

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

              value000 = Cons.walkUndefinedSlotTree(tree, (StandardObject.voidP(firstargtype) ? Stella.SGT_STELLA_UNKNOWN : ((StandardObject)(firstargtype))), (!illegalfirstargP) &&
                  Stella.warnAboutUndefinedMethodsP(), caller_MV_returnarray);
              value001 = ((Surrogate)(caller_MV_returnarray[0]));
            }
            { Stella_Object _return_temp = value000;

              MV_returnarray[0] = value001;
              return (_return_temp);
            }
          }
        }
      }
      { int minargs = slot.methodArgumentCount();
        int maxargs = minargs;

        if (Surrogate.subtypeOfMethodSlotP(Stella_Object.safePrimaryType(slot))) {
          { MethodSlot slot000 = ((MethodSlot)(slot));

            if (((BooleanWrapper)(KeyValueList.dynamicSlotValue(slot000.dynamicSlots, Stella.SYM_STELLA_METHOD_VARIABLE_ARGUMENTSp, Stella.FALSE_WRAPPER))).wrapperValue ||
                ((BooleanWrapper)(KeyValueList.dynamicSlotValue(slot000.dynamicSlots, Stella.SYM_STELLA_METHOD_BODY_ARGUMENTp, Stella.FALSE_WRAPPER))).wrapperValue) {
              minargs = minargs - 1;
              maxargs = Stella.NULL_INTEGER;
            }
          }
        }
        else {
        }
        if (Cons.badArgumentRangeP(tree, minargs, maxargs)) {
          return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_UNKNOWN, MV_returnarray));
        }
      }
      { Stella_Object otree = null;
        StandardObject otype = null;

        if (StandardObject.subTypeSpecOfP(firstargtype, Stella.SGT_STELLA_ARGUMENT_LIST)) {
          { Object [] caller_MV_returnarray = new Object[1];

            otree = Slot.finishWalkingArgumentListTree(slot, tree, firstargtype, caller_MV_returnarray);
            otype = ((StandardObject)(caller_MV_returnarray[0]));
          }
        }
        else {
          { Object [] caller_MV_returnarray = new Object[1];

            otree = slot.finishWalkingCallSlotTree(tree, firstargtype, caller_MV_returnarray);
            otype = ((StandardObject)(caller_MV_returnarray[0]));
          }
        }
        return (Slot.sysTreeIfNeeded(slot, otree, firstargtype, otype, MV_returnarray));
      }
    }
  }