return GraphdefToSplattedMlirTranslateFunction(
        file->getBuffer(), input_arrays, input_dtypes, input_shapes,
        output_arrays, control_output_arrays, graphdef_conversion_options,
        context);
  }
  return GraphdefToMlirTranslateFunction(file->getBuffer(), input_arrays,
                                         input_dtypes, input_shapes,
                                         output_arrays, control_output_arrays,

// Import options.
// NOLINTNEXTLINE
opt<std::string> input_arrays(
    "tf-input-arrays", llvm::cl::desc("Input tensor names, separated by ','"),
    llvm::cl::init(""));

// NOLINTNEXTLINE
opt<std::string> input_dtypes(
    "tf-input-data-types",
    llvm::cl::desc("(Optional) Input tensor data types, separated by ','. Use "
                   "'' if a single data type is skipped. The data type from "

  // Build the function type. Region arguments and extern values together
  // become the function arguments, with region arguments going first.
  auto input_types = llvm::to_vector<4>(entry.getArgumentTypes());
  for (auto input : extern_values) input_types.push_back(input.getType());

  // Terminator operands and pass through extern values (if enabled) together
  // become the function return values.

    }

    static String convertingValueSourceImpl(String valueSourceClassName, String inputType, String returnType, String conversion) {
        """
        abstract class $valueSourceClassName implements ${ValueSource.name}<$returnType, Params> {
            interface Params extends ${ValueSourceParameters.name} {
                Property<$inputType> getInput()
            }

            @Override $returnType obtain() {

    @Override
    public Type visitPrimitive(PrimitiveType t, Void unused) {
        TypeKind kind = t.getKind();
        if (kind == TypeKind.INT) {
            return Type.INT_TYPE;
        }
        if (kind == TypeKind.BYTE) {
            return Type.BYTE_TYPE;
        }
        if (kind == TypeKind.BOOLEAN) {
            return Type.BOOLEAN_TYPE;
        }

        given:
        buildFile << """
            abstract class TaskWithResultInput extends DefaultTask {

                @Input
                abstract ListProperty<${inputType}> getInput()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction void action() {
                    println(input.get())
                }

      callers.backward->getParentOfType<func::FuncOp>();

  const std::vector<Value>& operands = loop_operands_nm0;

  // Input types will be the same as the original loop body.
  std::vector<Type> input_types = GetValueTypes(operands);

  // Determine the results types.
  // Return ALL outputs, respecting the provided order of the Operations. This
  // makes it straightforward for users of this function to map the return

  MemoryTypeVector input_mtypes, output_mtypes;
  DeviceType device_type("");
  TF_RETURN_IF_ERROR(
      DeviceNameToDeviceType(n->assigned_device_name(), &device_type));
  TF_RETURN_IF_ERROR(MemoryTypesForNode(root.graph()->op_registry(),
                                        device_type, n->def(), &input_mtypes,
                                        &output_mtypes));

    private static final String RETURN_BOOLEAN = getMethodDescriptor(Type.BOOLEAN_TYPE);
    private static final String RETURN_OBJECT = getMethodDescriptor(OBJECT);
    private static final String RETURN_INT = getMethodDescriptor(Type.INT_TYPE);
    private static final String RETURN_VOID_FROM_STRING = getMethodDescriptor(Type.VOID_TYPE, STRING);
    private static final String RETURN_OBJECT_FROM_STRING = getMethodDescriptor(OBJECT, STRING);

  OpBuilder builder(module);

  std::vector<Type> input_types = GetValueTypes(inputs);
  std::vector<Type> output_types = GetValueTypes(outputs);
  builder.setInsertionPointToEnd(&module.getBodyRegion().back());
  func::FuncOp func_op = builder.create<func::FuncOp>(
      module.getLoc(), name,
      builder.getFunctionType(input_types, output_types));
  func_op.setPrivate();

  return func_op;
}