namespace tensorflow {

namespace {

// Gets tensor names from tensor_info and inserts them into the set of tensor
// names.
void GetTensorNamesFromTensorInfo(const TensorInfo& tensor_info,
                                  std::unordered_set<string>* tensor_names) {
  if (tensor_info.has_coo_sparse()) {
    // If the tensor is sparse we have to add all three tensors of the sparse
    // representations.

  for signature_key, signature_def in signature_def_map.items():
    for tensor_info in signature_def.inputs.values():
      try:
        exported_graph.get_tensor_by_name(tensor_info.name)
      except KeyError as exc:
        try:
          prefixed_name = signature_key + '_' + tensor_info.name
          exported_graph.get_tensor_by_name(prefixed_name)
          tensor_info.name = prefixed_name
        except KeyError:

  AssetFileDef asset_file_def{};
  asset_file_def.set_filename(MaybeStripAssetDirectoryPrefix(filename).str());

  tensorflow::TensorInfo tensor_info{};
  tensor_info.set_name(tensor_name.str());
  *asset_file_def.mutable_tensor_info() = tensor_info;

  return asset_file_def;
}

// Returns a list of "tf.entry_function" attribute's "inputs" comma-split
// values.
//

    std::vector<std::pair<string, Tensor>>& inputs) {
  const TensorProto* tensor_proto;
  std::set<std::string> seen_request_inputs;

  for (const auto& [alias, tensor_info] : signature.inputs()) {
    const std::string& feed_name = tensor_info.name();
    auto iter = request_inputs.find(alias);

    if (iter == request_inputs.end()) {
      auto default_inputs_iter = signature.defaults().find(alias);

  EXPECT_THAT(*asset_file_defs, SizeIs(1));

  const AssetFileDef& asset_file_def = *asset_file_defs->begin();
  EXPECT_THAT(asset_file_def.filename(), Eq("file_0.txt"));
  EXPECT_THAT(asset_file_def.tensor_info().name(), Eq("arg_0:0"));

  func::FuncOp main_func_op = GetMainFuncOp(*module_op);
  DictionaryAttr arg_attrs = main_func_op.getArgAttrDict(/*index=*/0);

    }
  )mlir");
  ASSERT_TRUE(module_op);

  AssetFileDef asset_file_def{};
  ASSERT_TRUE(
      TextFormat::ParseFromString(R"pb(filename: "vocab_file.txt",
                                       tensor_info { name: "arg_0:0" })pb",
                                  &asset_file_def));
  const std::vector<AssetFileDef> asset_file_defs = {asset_file_def};

  const absl::StatusOr<ExportedModel> exported_model =

  std::vector<std::pair<std::string, TensorInfo>> inputs;
  inputs.reserve(assets.size());
  for (const auto& asset : assets) {
    TensorInfo tensor_info;
    tensor_info.set_name(asset.tensor_name);
    tensor_info.set_dtype(DT_STRING);
    tensor_info.mutable_tensor_shape();
    inputs.push_back({asset.tensor_name, tensor_info});
  }

    Tensor assets_file_path_tensor = CreateStringTensor(io::JoinPath(
        export_dir, kSavedModelAssetsDirectory, asset_file_def.filename()));
    inputs->push_back(
        {asset_file_def.tensor_info().name(), assets_file_path_tensor});
  }
}

// Like Session::Run(), but uses the Make/Run/ReleaseCallable() API to avoid
// leaving behind non-GC'ed state.
//

          inputs={
              'x': tensor_info_x,
              'y': tensor_info_y
          },
          outputs={
              's': tensor_info_s,
              't': tensor_info_t
          },
          method_name='some_function')),
      'key2': (tf.compat.v1.saved_model.signature_def_utils.build_signature_def(
          inputs={
              'a': tensor_info_y,
              'b': tensor_info_x,
          },
          outputs={

  z = plus(x, y)

  tensor_info_x = tf.compat.v1.saved_model.utils.build_tensor_info(x)
  tensor_info_y = tf.compat.v1.saved_model.utils.build_tensor_info(y)
  tensor_info_z = tf.compat.v1.saved_model.utils.build_tensor_info(z)

  return {
      'key': (tf.compat.v1.saved_model.signature_def_utils.build_signature_def(
          inputs={
              'x': tensor_info_x,
              'y': tensor_info_y
          },