: public PassWrapper<LiftVariablesTestPass, OperationPass<ModuleOp>> {
 public:
  LiftVariablesTestPass() { session_ = new FakeSession(); }

  ~LiftVariablesTestPass() override { delete session_; }

  void runOnOperation() override {
    ModuleOp module = getOperation();
    if (failed(LiftVariables(module, session_))) signalPassFailure();
  }

 private:
  Session* session_;
};

// Removes unused results and related ops from while loops.
struct RemoveUnusedWhileResultsPass
    : public impl::RemoveUnusedWhileResultsPassBase<
          RemoveUnusedWhileResultsPass> {
  void runOnOperation() override;
};

// Prunes result defining op if possible, returns true if pruning was done.
bool TryPruneResultDefiningOp(TF::WhileRegionOp while_op, OpResult result) {
  // Don't prune if result is used.

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

struct BatchMatMulToEinsumPass
    : public impl::BatchMatMulToEinsumPassBase<BatchMatMulToEinsumPass> {
  void runOnOperation() override;
};

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

  patterns.add<ConvertTFBatchMatMulToEinsumOp<TF::BatchMatMulOp>,

struct ExecutorTPUV1IslandInliningPass
    : public impl::ExecutorTPUV1IslandInliningPassBase<
          ExecutorTPUV1IslandInliningPass> {
  void runOnOperation() override;
};

void ExecutorTPUV1IslandInliningPass::runOnOperation() {
  SymbolTable symbol_table(getOperation());
  Operation *nested_module = symbol_table.lookup(kNestedModule);
  if (!nested_module) return;

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

class VerifyQuantLegalization
    : public impl::VerifyQuantLegalizationBase<VerifyQuantLegalization> {
 public:
  void runOnOperation() override;
};

bool IsQuantType(Type type) {
  auto element_type = getElementTypeOrSelf(type);
  return mlir::isa<quant::UniformQuantizedType>(element_type) ||
         IsTFQintType(element_type);
}

namespace {
#define GEN_PASS_DEF_QUANTCONVERTCONST
#include "tensorflow/compiler/mlir/lite/quantization/ir/Passes.h.inc"

struct ConvertConstPass : public impl::QuantConvertConstBase<ConvertConstPass> {
  void runOnOperation() override;
};

struct QuantizedConstRewrite : public OpRewritePattern<QuantizeCastOp> {
  using OpRewritePattern<QuantizeCastOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(QuantizeCastOp qbarrier,

    : public impl::TensorDeviceCopyConversionPassBase<
          TensorDeviceCopyConversionPass> {
  void runOnOperation() override;
};

// Folds tf.IdentityOp and tf.IdentityNOp if op device and the argument devices
// from the defining ops match.
void TensorDeviceCopyConversionPass::runOnOperation() {
  func::FuncOp func_op = getOperation();

  auto should_fold_op_func = [&func_op](const Value &arg,

      TestLiftQuantizableSpotsAsFunctionsWithQuantizationSpecsPassBase;

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
      TestLiftQuantizableSpotsAsFunctionsWithQuantizationSpecsPass)

 private:
  void runOnOperation() override;
};

// `TestQuantizationSpecs` -> predefined `QuantizationSpecs` textproto.
absl::string_view GetQuantizationSpecsTextProto(
    const TestQuantizationSpecs test_specs) {
  switch (test_specs) {

    return "quant-convert-tpu-model-to-cpu";
  }
  StringRef getDescription() const final {
    return "Convert TPU models to CPU by rewriting TPU related operations.";
  }

  void runOnOperation() override;
};

class RemoveTpuOp : public RewritePattern {
 public:
  explicit RemoveTpuOp(MLIRContext* context)
      : RewritePattern(MatchAnyOpTypeTag(), /*benefit=*/1, context) {}

 private:

// invoked functions whether each input has the same data across replicas.
struct AnnotateParameterReplicationPass
    : public impl::AnnotateParameterReplicationPassBase<
          AnnotateParameterReplicationPass> {
  void runOnOperation() override;
};

// Returns the first value in the chain of operands, which is not defined by a
// tf.IdentityOp or a tf.ReadVariableOp.
Value SkipIdentityAndReadVariable(Value v) {