public static Stella_Object cppTranslateInlineCallTree(Cons tree) {
    { Cons calltree = ((Cons)(tree.rest.value));
      Cons arguments = ((calltree.value == Stella.SYM_STELLA_SYS_CALL_FUNCTION) ? calltree.nthRest(2) : calltree.nthRest(3));
      Cons tokenizedbody = Cons.tokenizeVerbatimMethodBody(calltree);

      if (tokenizedbody != null) {
        { List inlinedparameters = List.newList();
          String inlinedbody = null;
          boolean successP = true;

          { Object old$CurrentStream$000 = Stella.$CURRENT_STREAM$.get();

            try {
              Native.setSpecial(Stella.$CURRENT_STREAM$, OutputStringStream.newOutputStringStream());
              { Stella_Object token = null;
                Cons iter000 = tokenizedbody;

                loop000 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                  token = iter000.value;
                  { Surrogate testValue000 = Stella_Object.safePrimaryType(token);

                    if (Surrogate.subtypeOfStringP(testValue000)) {
                      { StringWrapper token000 = ((StringWrapper)(token));

                        ((OutputStream)(Stella.$CURRENT_STREAM$.get())).nativeStream.print(token000.wrapperValue);
                      }
                    }
                    else if (testValue000 == Stella.SGT_STELLA_CONS) {
                      { Cons token000 = ((Cons)(token));

                        { StringWrapper parameter = ((StringWrapper)(token000.value));
                          IntegerWrapper position = ((IntegerWrapper)(token000.rest.value));
                          Stella_Object argument = arguments.nth(position.wrapperValue);

                          if (!Stella_Object.sideEffectFreeExpressionP(argument)) {
                            if (inlinedparameters.memberP(parameter)) {
                              {
                                successP = false;
                                break loop000;
                              }
                            }
                            else {
                              inlinedparameters.insert(parameter);
                            }
                          }
                          if (!(Stella_Object.atomicExpressionP(argument))) {
                            ((OutputStream)(Stella.$CURRENT_STREAM$.get())).nativeStream.print("(");
                          }
                          Stella_Object.cppOutputStatement(Stella_Object.cppTranslateATree(Stella_Object.copyConsTree(argument)));
                          if (!(Stella_Object.atomicExpressionP(argument))) {
                            ((OutputStream)(Stella.$CURRENT_STREAM$.get())).nativeStream.print(")");
                          }
                        }
                      }
                    }
                    else {
                      { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

                        stream000.nativeStream.print("`" + testValue000 + "' is not a valid case option");
                        throw ((StellaException)(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
                      }
                    }
                  }
                }
              }
              inlinedbody = ((OutputStringStream)(((OutputStream)(Stella.$CURRENT_STREAM$.get())))).theStringReader();
              if (successP) {
                return (Cons.list$(Cons.cons(Stella.SYM_STELLA_CPP_VERBATIM, Cons.cons(VerbatimStringWrapper.newVerbatimStringWrapper(inlinedbody), Cons.cons(Stella.NIL, Stella.NIL)))));
              }

            } finally {
              Stella.$CURRENT_STREAM$.set(old$CurrentStream$000);
            }
          }
        }
      }
      return (Stella_Object.cppTranslateATree(calltree));
    }
  }