return "tf-saved-model-mark-initialized-variables-test";
  }

  StringRef getDescription() const final {
    return "Mark variables as initialized or not.";
  }

  void runOnOperation() override {
    TF::test_util::FakeSession session;
    if (failed(mlir::tf_saved_model::MarkInitializedVariablesInFunction(
            getOperation(), &session)))
      return signalPassFailure();
  }
};

    // This is a brief description of the pass.
    return "Applies optimization after quantization";
  }

  void runOnOperation() override;
};

#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/optimize.inc"

void OptimizePass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();

    registry.insert<quant::QuantizationDialect>();
    registry.insert<quantfork::QuantizationForkDialect>();
  }

  void runOnOperation() override;
};

static PassRegistration<ConvertFakeQuantToQdqPass> pass;

void ConvertFakeQuantToQdqPass::runOnOperation() {
  MLIRContext* ctx = &getContext();
  func::FuncOp func = getOperation();

  if (failed(

    : public impl::ClusterOutliningPassBase<ClusterOutliningPass> {
  void runOnOperation() override;
};

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

struct LaunchOutliningPass
    : public impl::LaunchOutliningPassBase<LaunchOutliningPass> {
  void runOnOperation() override;
};

void ReplaceClusterReturnWithReturn(tf_device::ReturnOp cluster_return_op,

    : public impl::RestoreFunctionNamePassBase<RestoreFunctionNamePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RestoreFunctionNamePass)

  explicit RestoreFunctionNamePass() = default;

  void runOnOperation() override;
};

void RestoreFunctionNameFromXlaCallModuleOp(TF::XlaCallModuleOp& call_op,
                                            SymbolTable& symbol_table) {

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

struct NameAnonymousIteratorsPass
    : public impl::NameAnonymousIteratorsPassBase<NameAnonymousIteratorsPass> {
  void runOnOperation() override;
};

template <typename OP>
int replace(OP op, int count) {
  OpBuilder builder(op);
  std::string name = absl::StrFormat("_iterator%d", count++);

  auto new_op = builder.create<TF::IteratorOp>(

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
      InsertCallOnceOpFromSessionInitializerPass)

 private:
  void runOnOperation() override;
};

void InsertCallOnceOpFromSessionInitializerPass::runOnOperation() {
  ModuleOp module = getOperation();

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module)) {

class DedupBoundInputBindingPass
    : public impl::DedupBoundInputBindingPassBase<DedupBoundInputBindingPass> {
  void runOnOperation() final;
};

void DedupBoundInputBindingPass::runOnOperation() {
  func::FuncOp func = getOperation();
  if (!mlir::tf_saved_model::IsExported(func)) return;
  llvm::SmallDenseMap<Attribute, unsigned, 8> unique_bound_inputs;

  SimpleTFDeviceAssignmentPass(const SimpleTFDeviceAssignmentPass&) {}
  explicit SimpleTFDeviceAssignmentPass(llvm::StringRef default_device) {
    default_device_ = std::string(default_device);
  }

  void runOnOperation() override {
    Builder builder(&getContext());
    Dialect* tf = getContext().getLoadedDialect<TensorFlowDialect>();
    getOperation().walk([&](Operation* op) {

struct FunctionalToExecutorDialectConversion
    : public impl::FunctionalToExecutorDialectConversionPassBase<
          FunctionalToExecutorDialectConversion> {
  void runOnOperation() override;
};
}  // end anonymous namespace

void FunctionalToExecutorDialectConversion::runOnOperation() {
  auto func = getOperation();
  if (func.isExternal()) return;
  if (!llvm::hasSingleElement(func)) {