return "Inserts a new function that wraps a SaveV2 op. The SaveV2 op saves "
           "the values of the VarHandleOps that are found in the initializer "
           "function of 'restore_op' type.";
  }

  void runOnOperation() override;
};

// Finds `tf.AssignVariableOp(tf.VarHandleOp, tf.Const)` patterns and removes
// `tf.AssignVariableOp`s and `tf.Const`s. Collects and returns the

 public:
  explicit QuantizeWeightPass(
      QuantizationComponentSpec quantization_component_spec)
      : quantization_component_spec_(quantization_component_spec) {}

 private:
  void runOnOperation() override;
  QuantizationComponentSpec quantization_component_spec_;
};

// Collects quantizable target ops, then insert Q-DQ quantization patterns.
class QuantizeWeight : public OpRewritePattern<ConstantOp> {

  StringRef getArgument() const final { return "tfl-parse-stablehlo-ops"; }
  StringRef getDescription() const final {
    return "This pass will legalize TFLite custom Ops to StableHLO ops.";
  }

 private:
  void runOnOperation() override;

  void getDependentDialects(DialectRegistry& registry) const override {
    mlir::stablehlo::registerAllDialects(registry);
  }
  inline TFL::ConstBytesAttr CustomOption(OpBuilder* builder,

  }

  // NOTE: The implementation is mostly copypasted from
  // third_party/tensorflow/compiler/mlir/tfrt/transforms/lower_saved_model.cc
  // with the original code trimmed and adapted as needed.
  void runOnOperation() override {
    auto module = getOperation();
    if (!tf_saved_model::HasTfSavedModelSemantics(module)) return;

    // Clean up functions from tf_saved_model attributes.
    OpBuilder builder(module);

class LegalizeVariablesPass
    : public impl::LegalizeVariablesPassBase<LegalizeVariablesPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LegalizeVariablesPass)

  void runOnOperation() override {
    auto module = getOperation();
    // If TFLite variable legalization is not allowed, then we skip this pass.
    if (auto legalize_tfl_variables_attr =
            module->getAttr(kLegalizeTflVariables)) {

// This transformation pass replicates TensorList initialization ops.
class ReplicateTensorListInitOps
    : public impl::ReplicateTensorListInitOpsPassBase<
          ReplicateTensorListInitOps> {
 public:
  void runOnOperation() override {
    getOperation().walk([](Operation* op) {
      if (auto tl_reserve = dyn_cast<TensorListReserveOp>(op)) {
        ReplicateTensorListForUses(tl_reserve);
      }

    return "quant-import-stats";
  }
  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Import quantization stats to the model";
  }

  void runOnOperation() override;

  void getDependentDialects(DialectRegistry &registry) const override {
    registry.insert<quant::QuantizationDialect,
                    quantfork::QuantizationForkDialect>();
  }

  }

  void getDependentDialects(DialectRegistry& registry) const override {
    registry.insert<TF::TensorFlowDialect, quant::QuantizationDialect>();
  }

 private:
  void runOnOperation() override;

  bool test_mode_;
  tensorflow::quantization::QuantizationOptions quant_options_;

  // Initialize for tests.
  void initializeForTest() {
    if (!test_mode_) return;

          OperationPass<ModuleOp>> {
 public:
  static ::mlir::TypeID resolveTypeID() {
    static ::mlir::SelfOwningTypeID id;
    return id;
  }

 private:
  void runOnOperation() override {
    ModuleOp op = this->getOperation();
    DerivedT& derived = *static_cast<DerivedT*>(this);
    auto& analysis = this->template getAnalysis<AnalysisT>();

    for (auto func : op.getOps<func::FuncOp>())

 public:
  StringRef getArgument() const final { return "rename-entrypoint-to-main"; }
  StringRef getDescription() const final {
    return "Renames the entrypoint in SavedModel to `main`";
  }

  void runOnOperation() override {
    auto fail = [&](Operation* op, std::string message) {
      op->emitError(message);
      signalPassFailure();
    };

    DenseMap<StringRef, func::FuncOp> entrypoints;