public Stella_Object finishWalkingCallSlotTree(Cons tree, StandardObject firstargtype, Object [] MV_returnarray) {
    { MethodSlot self = this;

      { Symbol methodname = self.slotName;
        StandardObject otypespec = self.computeReturnTypeSpec(firstargtype);
        Stella_Object otree = null;

        { List ptypespecs = self.methodParameterTypeSpecifiers();
          int nofparameters = ptypespecs.length();
          Cons cursor = tree.rest.rest;

          { StandardObject targetts = null;
            Cons iter000 = ptypespecs.rest();
            int pindex = Stella.NULL_INTEGER;
            int iter001 = 2;
            int upperBound000 = nofparameters;
            boolean unboundedP000 = upperBound000 == Stella.NULL_INTEGER;

            loop000 : for (;(!(iter000 == Stella.NIL)) &&
                      (unboundedP000 ||
                       (iter001 <= upperBound000)); iter000 = iter000.rest, iter001 = iter001 + 1) {
              targetts = ((StandardObject)(iter000.value));
              pindex = iter001;
              targetts = StandardObject.computeRelativeTypeSpec(targetts, firstargtype);
              if ((pindex == nofparameters) &&
                  ((BooleanWrapper)(KeyValueList.dynamicSlotValue(self.dynamicSlots, Stella.SYM_STELLA_METHOD_VARIABLE_ARGUMENTSp, Stella.FALSE_WRAPPER))).wrapperValue) {
                tree.nthRestSetter(Cons.walkVariableArguments(cursor, self, firstargtype), pindex);
                break loop000;
              }
              cursor.value = Stella_Object.walkExpressionTree(cursor.value, targetts, methodname, true, new Object[1]);
              cursor = cursor.rest;
            }
          }
        }
        { Stella_Object arg = null;
          Cons iter002 = tree.rest;

          for (;!(iter002 == Stella.NIL); iter002 = iter002.rest) {
            arg = iter002.value;
            if (Stella_Object.vrletExpressionP(arg)) {
              return (Cons.percolateOutVrletExpression(tree, ((Cons)(arg)), otypespec, MV_returnarray));
            }
          }
        }
        if (MethodSlot.inlineMethodCallP(self)) {
          otree = MethodSlot.walkInlineMethodCall(self, tree.rest, firstargtype);
          if (otree != null) {
            return (Stella_Object.sysTree(otree, otypespec, MV_returnarray));
          }
        }
        if (self.methodFunctionP) {
          otree = Cons.cons(Stella.SYM_STELLA_SYS_CALL_FUNCTION, tree.concatenate(Stella.NIL, Stella.NIL));
        }
        else {
          otree = Cons.list$(Cons.cons(Stella.SYM_STELLA_SYS_CALL_METHOD, Cons.cons(self.slotOwner, Cons.cons(tree.concatenate(Stella.NIL, Stella.NIL), Stella.NIL))));
        }
        { Stella_Object _return_temp = otree;

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