f->erase();
    }
  });
}

class XlaCallModuleSerializationPass
    : public impl::XlaCallModuleSerializationPassBase<
          XlaCallModuleSerializationPass> {
 public:
  void runOnOperation() override {
    mlir::ModuleOp module = getOperation();
    mlir::SymbolTableCollection symbol_table;

    mlir::WalkResult result =
        module.walk([&](mlir::TF::XlaCallModuleOp xla_call_module) {

  void getDependentDialects(DialectRegistry &registry) const override {
    registry.insert<mlir::tf_saved_model::TensorFlowSavedModelDialect,
                    ml_program::MLProgramDialect>();
  }

  void runOnOperation() override {
    if (failed(convertTFGlobals(getOperation()))) {
      signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> CreateLowerGlobalsToMlProgramPass() {

#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

struct ConvertTfControlFlowToScf
    : public impl::ConvertTfControlFlowToScfPassBase<
          ConvertTfControlFlowToScf> {
  void runOnOperation() override {
    RewritePatternSet patterns(&getContext());
    populateTfControlFlowToScfPatterns(&getContext(), &patterns);
    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
  }
};

#include "tensorflow/compiler/mlir/tf2xla/internal/passes/clustering_passes.h.inc"

struct MarkOpsForOutsideCompilation
    : public impl::MarkOpsForOutsideCompilationPassBase<
          MarkOpsForOutsideCompilation> {
  void runOnOperation() override;
};

// Adds any canonicalization patterns to list of supported `patterns`.
// TODO(b/161726307): Move or import the relevant patterns to LowerTF pass and
// remove this.

struct TPUVariableRuntimeReformattingPass
    : public impl::TPUVariableRuntimeReformattingPassBase<
          TPUVariableRuntimeReformattingPass> {
  void runOnOperation() final;
};

// Returns the earlier value of which `v` is an identity. If `skipped` is
// provided, it will be used to store the identity nodes skipped.
Value SkipIdentity(Value v, bool allow_other_use,

  }

  // Determine if the unused Q-DQ pairs need to be removed. For weight-only
  // quantizable ops, Q-DQ ops need to be preserved.
  bool shouldKeepUnusedQdqPattern();

  void runOnOperation() override;

 private:
  QuantizationSpecs quant_specs_;

  Option<bool> weight_quantization_{
      *this, "weight-quantization", llvm::cl::init(false),

    registry.insert<TF::TensorFlowDialect>();
  }

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LiftTfliteFlexOpsPass)

  void runOnOperation() override {
    MLIRContext* context = &getContext();
    func::FuncOp func = getOperation();

    mlir::RewritePatternSet patterns(context);
    AddLiftTfliteFlexOpsPatterns(context, patterns);

    // TODO(b/299514833): Remove TensorFlowDialect usage.
    registry.insert<shape::ShapeDialect, mlir::TF::TensorFlowDialect>();
  }

  void runOnOperation() override {
    RewritePatternSet patterns(&getContext());
    patterns.add<UnfuseBatchNormTrainingPattern>(&getContext());
    patterns.add<UnfuseBatchNormInferencePattern>(&getContext());

  void getDependentDialects(mlir::DialectRegistry &registry) const override {
    XlaCallModuleDeserializationPassBase::getDependentDialects(registry);
    mlir::func::registerAllExtensions(registry);
  }

  void runOnOperation() override {
    ModuleOp module = getOperation();
    SymbolTableCollection symbol_tables;
    WalkResult result = module.walk([&](XlaCallModuleOp op) {

  }
};

class OutlineCompositesPass
    : public impl::OutlineCompositesPassBase<OutlineCompositesPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OutlineCompositesPass)

  void runOnOperation() override {
    auto func = getOperation();
    RewritePatternSet patterns(&getContext());
    patterns.add<OutlineGELU>(&getContext());
    if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {