tensorflow::Summary s;
  std::unordered_set<tensorflow::string> tags;
  Safe_TF_StatusPtr status(TF_NewStatus());
  for (int input_num = 0; input_num < TF_NumInputs(ctx); ++input_num) {
    TF_Tensor* input;
    TF_GetInput(ctx, input_num, &input, status.get());
    Safe_TF_TensorPtr safe_input_ptr(input);
    if (TF_GetCode(status.get()) != TF_OK) {
      TF_OpKernelContext_Failure(ctx, status.get());

  // XLA compiler arguments.
  for (int64_t input_num = offset; input_num < input_arg_size; ++input_num) {
    const Tensor* input = inputs[input_num];

    XlaCompiler::Argument arg;
    if (variable_info_lookup.count(input_num)) {
      // Handles tf.resource variables.
      TF_RET_CHECK(input->dtype() == DT_RESOURCE);
      const VariableInfo& variable = *variable_info_lookup[input_num];
      arg.kind = XlaCompiler::Argument::kResource;

  TF_CHECK_OK(CreateVariableInfoLookup(variable_args, variable_info_lookup));
  for (int64_t input_num = 0; input_num < inputs.size(); ++input_num) {
    const Tensor* input = inputs[input_num];

    XlaCompiler::Argument& arg = out[input_num];
    if (variable_info_lookup.count(input_num) && device != nullptr) {
      // Handles resource variables.
      TF_RET_CHECK(input->dtype() == DT_RESOURCE);

  OperationState op_state(loc, op_name);

  for (auto input_num : op.inputs) {
    if (input_num == -1) {
      assert(optional_arg_marker != nullptr);
      op_state.addOperands({optional_arg_marker});
    } else {
      op_state.addOperands({vals_map.at(input_num)});
    }
  }

  for (auto output_num : op.outputs) {
    auto& tensor = *tensors.at(output_num);

    if (!asset_op) continue;

    const StringRef input_name = input_names[arg_idx];
    ConvertMainArgAttrs(main_func_op, arg_idx, /*index_path=*/input_name);

    // This assumes that the final tensor name in `GraphDef` is equal to
    // `input_name`.
    asset_file_defs.emplace_back(CreateAssetFileDef(
        asset_op.getFilenameAttr(), /*tensor_name=*/input_name));
  }

  return asset_file_defs;
}

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project

namespace mlir {
namespace quant {

constexpr StringRef kTfEntryFunctionAttr = "tf.entry_function";

void AddEntryFunctionInput(StringRef input_name, func::FuncOp func_op) {
  auto entry_func_attr =
      func_op->getAttrOfType<DictionaryAttr>(kTfEntryFunctionAttr);
  if (!entry_func_attr) return;

      for idx, input_name in enumerate(node.input):
        if input_name in output_renaming_map:
          node.input[idx] = output_renaming_map[input_name]
      # Update the control inputs referring to the pre-renaming node.
      updating_inputs = []
      for input_name in reversed(node.input):
        if input_name.startswith('^') and input_name[1:] in output_renaming_map:

  std::string expected_key = tflite::optimize::kTfLiteReducedPrecisionKey;
  std::string expected_value = "test_data";

  // Load input model
  auto input_fbm = tflite::FlatBufferModel::BuildFromFile(
      "tensorflow/lite/testdata/sparse_tensor.bin");
  tflite::ModelT input_model;
  input_fbm->GetModel()->UnPackTo(&input_model);

  // Populate input metadata
  auto model_metadata_buffer = std::make_unique<tflite::BufferT>();

        for (StringRef input_name : fn_input_names) {
          if (input_name_set.contains(input_name)) {
            // Found a duplicated name, all input names will be prefixed by
            // their corresponding function names.
            need_prefix_for_input_name = true;
          }
          input_name_set.insert(input_name);
          fn_input_name_vec.push_back(function_name);
        }

    ValidateAssets(export_dir, bundle);
    // Retrieve the regression signature from the bundle.
    const auto& signature_def = bundle.GetSignatures().at("regress_x_to_y");

    const string input_name = signature_def.inputs().at(kRegressInputs).name();
    const string output_name =
        signature_def.outputs().at(kRegressOutputs).name();

    std::vector<tstring> serialized_examples;