public static Stella_Object walkInlineMethodCall(MethodSlot method, Cons walkedargs, StandardObject firstargtype) {
    { Stella_Object body = MethodSlot.inlinableMethodBody(method);
      int nofreferences = Stella.NULL_INTEGER;
      Stella_Object inlinearg = null;
      boolean successP = true;

      if (Stella_Object.verbatimTreeP(body) &&
          (Cons.lookupVerbatimTree(((Cons)(body)), null) != null)) {
        return (MethodSlot.yieldVerbatimInlineCallTree(method, walkedargs));
      }
      body = Stella_Object.copyConsTree(body);
      { Object old$InliningmethodcallP$000 = Stella.$INLININGMETHODCALLp$.get();
        Object old$Methodbeingwalked$000 = Stella.$METHODBEINGWALKED$.get();

        try {
          Native.setBooleanSpecial(Stella.$INLININGMETHODCALLp$, true);
          Native.setSpecial(Stella.$METHODBEINGWALKED$, method);
          { Symbol var = null;
            Cons iter000 = method.methodParameterNames().theConsList;
            StandardObject tspec = null;
            Cons iter001 = method.methodParameterTypeSpecifiers().theConsList;
            Stella_Object arg = null;
            Cons iter002 = walkedargs;
            int i = Stella.NULL_INTEGER;
            int iter003 = 0;

            for (;(!(iter000 == Stella.NIL)) &&
                      ((!(iter001 == Stella.NIL)) &&
                       (!(iter002 == Stella.NIL))); 
                  iter000 = iter000.rest,
                  iter001 = iter001.rest,
                  iter002 = iter002.rest,
                  iter003 = iter003 + 1) {
              var = ((Symbol)(iter000.value));
              tspec = ((StandardObject)(iter001.value));
              arg = iter002.value;
              i = iter003;
              if ((i == 0) &&
                  (Slot.mixinMethodP(method) &&
                   Stella.translateToSingleInheritanceLanguageP())) {
                tspec = firstargtype;
              }
              else {
                tspec = StandardObject.computeRelativeTypeSpec(tspec, firstargtype);
              }
              Symbol.walkADeclaration(var, tspec, null, true);
              Symbol.setLocalVariableInfo(var, Stella.KWD_INLINE_ARGUMENT, arg);
              Symbol.setLocalVariableInfo(var, Stella.KWD_INLINE_REFERENCES, IntegerWrapper.wrapInteger(0));
            }
          }
          body = Stella_Object.walkExpressionTree(body, method.type(), Stella.SYM_STELLA_INLINE_CALL, true, new Object[1]);

        } finally {
          Stella.$METHODBEINGWALKED$.set(old$Methodbeingwalked$000);
          Stella.$INLININGMETHODCALLp$.set(old$InliningmethodcallP$000);
        }
      }
      if (Stella_Object.proceduralExpressionP(body)) {
        successP = false;
      }
      if (successP) {
        { Symbol var = null;
          Cons iter004 = method.methodParameterNames().theConsList;

          loop001 : for (;!(iter004 == Stella.NIL); iter004 = iter004.rest) {
            var = ((Symbol)(iter004.value));
            inlinearg = Symbol.getLocalVariableInfo(var, Stella.KWD_INLINE_ARGUMENT);
            nofreferences = ((IntegerWrapper)(Symbol.getLocalVariableInfo(var, Stella.KWD_INLINE_REFERENCES))).wrapperValue;
            switch (nofreferences) {
              case 0: 
                if (!Stella_Object.sideEffectFreeExpressionP(inlinearg)) {
                  successP = false;
                  break loop001;
                }
              break;
              case 1: 
              break;
              default:
                if (!(Stella_Object.sideEffectFreeExpressionP(inlinearg) &&
                    ((Stella_Object.estimatedEvaluationCost(inlinearg) * nofreferences) <= 2))) {
                  successP = false;
                  break loop001;
                }
              break;
            }
          }
        }
      }
      { Symbol var = null;
        Cons iter005 = method.methodParameterNames().theConsList;

        for (;!(iter005 == Stella.NIL); iter005 = iter005.rest) {
          var = ((Symbol)(iter005.value));
          var = var;
          Stella.popVariableBinding();
        }
      }
      return ((successP ? body : null));
    }
  }