IncludeType type = enumSerializer.read(decoder);
            int argsCount = decoder.readSmallInt();
            if (argsCount == 0) {
                return IncludeWithSimpleExpression.create(value, isImport, type);
            }
            List<Expression> args = new ArrayList<Expression>(argsCount);
            for (int i = 0; i < argsCount; i++) {
                args.add(expressionSerializer.read(decoder));
            }

        }

        @Override
        public Object intercept(Invocation invocation, String consumer) throws Throwable {
            int argsCount = invocation.getArgsCount();
            if (1 <= argsCount && argsCount <= 3) {
                Optional<Process> result = tryCallExec(invocation.getReceiver(), invocation.getArgument(0), invocation.getOptionalArgument(1), invocation.getOptionalArgument(2), consumer);

            daemonUid = decoder.readString();
            priority = DaemonParameters.Priority.values()[decoder.readSmallInt()];
            int argCount = decoder.readSmallInt();
            startupOpts = new ArrayList<String>(argCount);
            for (int i = 0; i < argCount; i++) {
                startupOpts.add(decoder.readString());
            }
            int additionalClassPathLength = decoder.readSmallInt();

        result.endControlFlow();
    }

    private void returnTrueIfNoArgumentsLeft(int argCount, CallInterceptionRequest leafInCurrent) {
        CodeBlock argClasses = argClassesExpression(leafInCurrent);

        result.beginControlFlow("if (argumentClasses.length == $L)", argCount);
        result.add("/** Matched $L */\n", JavadocUtils.interceptedCallableLink(leafInCurrent));

                }
            });
        }
    }

    private void generateInvocationWhenArgsMatched(CallInterceptionRequest request, int argCount) {
        result.beginControlFlow("if (invocation.getArgsCount() == $L)", argCount);
        CodeBlock argsCode = prepareInvocationArgs(request);
        emitInvocationCodeWithReturn(request, argsCode);
        result.endControlFlow();
    }

class UneraseCallHelper<Fn, TReturn> {
 public:
  template <typename... ArgsOut>
  static tensorflow::StatusOr<TaggedValue> Call(const char* name, Fn functor_,
                                                int argument_index,
                                                const TaggedValue& args_in,
                                                ArgsOut... args) {
    // Call concrete type function
    TReturn ret = functor_(args...);

           << func_name;
  }

  FunctionType func_ty = func.getFunctionType();
  int func_arg_count = func_ty.getNumInputs();
  int arg_count = getArgs().size();

  if (arg_count != func_arg_count) {
    return emitError() << "argument count mismatch: 'args' has " << arg_count
                       << " argument(s), but '" << func_name << "' expects "
                       << func_arg_count;
  }

           << func;
  }

  FunctionType function_ty = function.getFunctionType();
  int func_arg_count = function_ty.getNumInputs();
  int arg_count = op.getArgs().size();

  if (arg_count != func_arg_count) {
    return op.emitError() << "argument count mismatch: 'args' has " << arg_count
                          << " arguments, but '" << func << "' expects "
                          << func_arg_count;
  }