if (op.getKeyIndex() != kTextFileIndex_WholeLine ||
        op.getValueIndex() != kTextFileIndex_LineNumber) {
      return failure();
    }

    // Try to find filename from constant op.
    DenseStringElementsAttr filename_attr;
    if (!matchPattern(op.getFilename().getDefiningOp(),
                      m_Constant(&filename_attr))) {
      return failure();
    }

    if (filename_attr.getRawStringData().size() != 1) {

      DenseStringElementsAttr attr;
      if (!matchPattern(op.getOperation(), m_Constant(&attr))) {
        continue;
      }

      ArrayRef<StringRef> values = attr.getRawStringData();
      if (values.size() != 1 || values[0] != "%FILE_PLACEHOLDER") {
        continue;
      }

      op.setValueAttr(DenseStringElementsAttr::get(shaped_type, {filename}));
    }
  }

#include "tensorflow/core/platform/tstring.h"
#include "tsl/platform/ml_dtypes.h"

namespace tensorflow {

using llvm::ArrayRef;
using llvm::SmallVector;
using mlir::Builder;
using mlir::DenseStringElementsAttr;
using mlir::ElementsAttr;
using mlir::RankedTensorType;
using mlir::ShapedType;
using mlir::Type;
using tensorflow::errors::InvalidArgument;

static TensorProto ConvertToProto(const Tensor& input_tensor,

  auto value_or_status = ConvertTensor(tensor, &b);
  ASSERT_TRUE(value_or_status.ok());
  auto attr = value_or_status.value();

  EXPECT_TRUE(mlir::isa<mlir::DenseStringElementsAttr>(attr));
  auto string_attr = mlir::cast<mlir::DenseStringElementsAttr>(attr);
  auto string_values = string_attr.getRawStringData();
  ASSERT_EQ(string_values.size(), 4);
  EXPECT_EQ(string_values[0], mlir::StringRef("one"));

  const ElementsAttr const_value = const_op.getValue();

  // This cast is guaranteed to succeed. See `ConvertToTensorProto` from
  // tensorflow/core/ir/importexport/convert_tensor.cc.
  const auto str_attr = cast<DenseStringElementsAttr>(const_value);

  // Sum the sizes of each string.
  return absl::c_accumulate(
      str_attr.getRawStringData(), 0,
      [](int64_t acc, const StringRef str_value) -> int64_t {

      ShapedType shaped_type =
          RankedTensorType::get({1}, TF::StringType::get(builder.getContext()));
      auto const_op = builder.create<TF::ConstOp>(
          asset.getLoc(),
          DenseStringElementsAttr::get(shaped_type, {filename}));
      for (auto init_op : init_table_from_text_file_ops_to_erase) {
        // Replace the InitializeTableFromTextFileV2Op to use the saved model's
        // asset filepath.

    mode_string_value.emplace_back(is_training ? "train" : "inference");
    builder->setInsertionPoint(embedding_op);
    auto enqueue_mode = builder->create<TF::ConstOp>(
        embedding_op->getLoc(),
        DenseStringElementsAttr::get(
            RankedTensorType::get({}, builder->getType<TF::StringType>()),
            mode_string_value));

    auto outside_compilation_attr =

        RankedTensorType type = RankedTensorType::get(
            {}, TF::StringType::get(builder.getContext()));
        auto const_op = builder.create<TF::ConstOp>(
            builder.getUnknownLoc(),
            DenseStringElementsAttr::get(type, {filename}));

        it = const_ops.insert({asset.getSymName(), const_op}).first;
      }

      argument.replaceAllUsesWith(it->second.getOutput());

      RankedTensorType::get(/*shape=*/{static_cast<int64_t>(str_values.size())},
                            /*elementType=*/builder.getType<TF::StringType>());

  return builder.create<TF::ConstOp>(
      loc, DenseStringElementsAttr::get(
               tensor_type,
               SmallVector<StringRef>(str_values.begin(), str_values.end())));
}

// Creates a new argument for `func_op` that accepts a string tensor containing

      RankedTensorType::get(/*shape=*/{static_cast<int64_t>(str_values.size())},
                            /*elementType=*/builder.getType<TF::StringType>());

  return builder.create<TF::ConstOp>(
      loc, DenseStringElementsAttr::get(
               tensor_type,
               SmallVector<StringRef>(str_values.begin(), str_values.end())));
}

// Creates a 1D string array constant for "tensor_names" input of `RestoreV2`