(*name_to_node_map)[node->name()] = node;
  }
}

// Strips off the tensor part of the tensor_name to get the node_name.
const string GetNodeNameFromTensorName(string tensor_name) {
  if (tensor_name[0] == '^') {
    tensor_name.erase(0, 1);
  }
  std::vector<string> tensor_name_parts = str_util::Split(tensor_name, ':');
  return tensor_name_parts[0];
}

//
//   Callers must ensure all the named tensors are indeed stored in the
//   checkpoint.
Status RestoreV2(AbstractContext* ctx, AbstractTensorHandle* const prefix,
                 AbstractTensorHandle* const tensor_names,
                 AbstractTensorHandle* const shape_and_slices,
                 absl::Span<AbstractTensorHandle*> tensors,
                 absl::Span<DataType> dtypes, const char* name,

}

// Creates a 1D string array constant for "tensor_names" input of `RestoreV2`
// op. The `ConstOp` will be created at `builder`'s current insertion point.
TF::ConstOp CreateTensorNamesConst(const ArrayRef<std::string> tensor_names,
                                   OpBuilder& builder) {
  const auto loc = NameLoc::get(builder.getStringAttr("tensor_names"));
  return Create1DStringConst(tensor_names, loc, builder);
}

}

// Creates a 1D string array constant for "tensor_names" input of `RestoreV2`
// op. The `ConstOp` will be created at `builder`'s current insertion point.
TF::ConstOp CreateTensorNamesConst(const ArrayRef<std::string> tensor_names,
                                   OpBuilder& builder) {
  const auto loc = NameLoc::get(builder.getStringAttr("tensor_names"));
  return Create1DStringConst(tensor_names, loc, builder);
}

namespace tensorflow {
namespace ops {

// Restores tensors from a V2 checkpoint.
Status RestoreV2(AbstractContext* ctx, AbstractTensorHandle* const prefix,
                 AbstractTensorHandle* const tensor_names,
                 AbstractTensorHandle* const shape_and_slices,
                 absl::Span<AbstractTensorHandle*> tensors,
                 absl::Span<DataType> dtypes, const char* name = nullptr,

          }
        }
      }
      op {
        name: "RestoreV2"
        input_arg {
          name: "prefix"
          type: DT_STRING
        }
        input_arg {
          name: "tensor_names"
          type: DT_STRING
        }
        input_arg {
          name: "shape_and_slices"
          type: DT_STRING
        }
        output_arg {
          name: "tensors"

}

// Op: RestoreV2()
// Summary:
//
// Description:
Status RestoreV2(AbstractContext* ctx, AbstractTensorHandle* const prefix, AbstractTensorHandle* const tensor_names, AbstractTensorHandle* const shape_and_slices, absl::Span<AbstractTensorHandle*> tensors, absl::Span<DataType> dtypes, const char* name, const char* raw_device_name) {
  AbstractOperationPtr op_ptr(ctx->CreateOperation());

//
Status RestoreV2(AbstractContext* ctx, AbstractTensorHandle* const prefix, AbstractTensorHandle* const tensor_names, AbstractTensorHandle* const shape_and_slices, absl::Span<AbstractTensorHandle*> tensors, absl::Span<DataType> dtypes, const char* name = nullptr, const char* raw_device_name = nullptr);

}  // namespace ops

    const std::vector<std::string>& tensor_names) {
  absl::flat_hash_map<std::string, int> name_to_index;
  for (const auto& index_and_tensor : llvm::enumerate(subgraph.tensors)) {
    name_to_index[index_and_tensor.value()->name] = index_and_tensor.index();
  }

  std::vector<int> indices;
  indices.reserve(tensor_names.size());

  for (const auto& name : tensor_names) {
    auto found = name_to_index.find(name);

  let arguments = (ins
    Arg<TF_StrTensor, [{Must have a single element.  The prefix of a V2 checkpoint.}]>:$prefix,
    Arg<TF_StrTensor, [{shape {N}.  The names of the tensors to be restored. This is tensor name in the model.}]>:$tensor_names,
    Arg<TF_StrTensor, [{shape {N}.  The slice specs of the tensors to be restored.
Empty strings indicate that they are non-partitioned tensors.}]>:$shape_and_slices,
    // VarHandles for restored tensors.