class MarkInitializedVariablesTestPass
    : public PassWrapper<MarkInitializedVariablesTestPass,
                         OperationPass<func::FuncOp>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MarkInitializedVariablesTestPass)

  StringRef getArgument() const final {
    return "tf-saved-model-mark-initialized-variables-test";
  }

  StringRef getDescription() const final {

namespace debug_test {

class NopPass : public mlir::PassWrapper<NopPass, mlir::OperationPass<>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(NopPass)

  void runOnOperation() override {}
};

class MutatePass : public mlir::PassWrapper<MutatePass, mlir::OperationPass<>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MutatePass)

  void runOnOperation() override {
    mlir::OpBuilder builder(&getContext());

namespace {

class TestTensorArraySideEffectAnalysis
    : public mlir::PassWrapper<TestTensorArraySideEffectAnalysis,
                               mlir::OperationPass<mlir::ModuleOp>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
      TestTensorArraySideEffectAnalysis)

 private:
  llvm::StringRef getArgument() const final {
    return "tfrt-test-tensor-array-effect";
  }
  llvm::StringRef getDescription() const final {

#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

struct IdentifyDilatedConvPass
    : public impl::IdentifyDilatedConvPassBase<IdentifyDilatedConvPass> {
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(IdentifyDilatedConvPass)
  void runOnOperation() override;
};

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

#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/passes.h.inc"

namespace {

class OptimizeGraphPass
    : public impl::OptimizeGraphPassBase<OptimizeGraphPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OptimizeGraphPass)

  explicit OptimizeGraphPass() = default;

 private:
  void runOnOperation() override;
};

// This pass verifies that the TFL ops meet the TFL runtime constraints.
class RuntimeVerifyPass
    : public impl::RuntimeVerifyPassBase<RuntimeVerifyPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RuntimeVerifyPass)

  explicit RuntimeVerifyPass() {}

 private:
  void runOnOperation() override;
};

void RuntimeVerifyPass::runOnOperation() {

#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/passes.h.inc"

namespace {

class UnfuseMhloBatchNormPass
    : public impl::UnfuseMhloBatchNormPassBase<UnfuseMhloBatchNormPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnfuseMhloBatchNormPass)

  explicit UnfuseMhloBatchNormPass() = default;

 private:
  void runOnOperation() override;
};

void UnfuseMhloBatchNormPass::runOnOperation() {

namespace tensorflow {
namespace quantization {
namespace mlir_dump_test {

class NoOpPass
    : public mlir::PassWrapper<NoOpPass, mlir::OperationPass<mlir::ModuleOp>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(NoOpPass)

  NoOpPass() = default;

  llvm::StringRef getArgument() const final { return "no-op-pass"; }

  void runOnOperation() override {
    // Noop pass does nothing on the operation.
  }

class QuantizationUnitLoc : public CallSiteLoc {
 public:
  using QuantizationUnit =
      tensorflow::quantization::UnitWiseQuantizationSpec::QuantizationUnit;

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizationUnitLoc)

  QuantizationUnitLoc(MLIRContext* context, const QuantizationUnit& unit);

  // Checks if the given location is QuantizationUnitLoc. Users could call

// initializer is given.
class InsertCallOnceOpFromSessionInitializerPass
    : public impl::InsertCallOnceOpFromSessionInitializerPassBase<
          InsertCallOnceOpFromSessionInitializerPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
      InsertCallOnceOpFromSessionInitializerPass)

 private:
  void runOnOperation() override;
};

void InsertCallOnceOpFromSessionInitializerPass::runOnOperation() {