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());

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

class CompositeLoweringPass
    : public impl::CompositeLoweringPassBase<CompositeLoweringPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CompositeLoweringPass);

  void runOnOperation() override;
};

#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/generated_composite_lowering.inc"

// for canonicalization and folding which is not offered directly by the
// shlo implementation.
class SHLOSimplifyPass : public impl::SHLOSimplifyPassBase<SHLOSimplifyPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SHLOSimplifyPass)

  void runOnOperation() override {
    ModuleOp module = getOperation();
    RewritePatternSet patterns(&getContext());
    populateWithGenerated(patterns);

namespace {

// Converts XlaCallModuleOps to func.call.
class XlaCallModuleToCallPass
    : public impl::XlaCallModuleToCallPassBase<XlaCallModuleToCallPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(XlaCallModuleToCallPass)

  explicit XlaCallModuleToCallPass() = default;

 private:
  void runOnOperation() override;
};

// Converts XlaCallModuleOps to func.call.

// arguments to functions, to TFLite variables.
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.

using ::tensorflow::quantization::RunPassesOnModuleOp;

class QuantizeCompositeFunctionsPass
    : public impl::QuantizeCompositeFunctionsPassBase<
          QuantizeCompositeFunctionsPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizeCompositeFunctionsPass)

  using impl::QuantizeCompositeFunctionsPassBase<
      QuantizeCompositeFunctionsPass>::QuantizeCompositeFunctionsPassBase;

  explicit QuantizeCompositeFunctionsPass(

          TestPostCalibrationComponentPass> {
 public:
  using impl::TestPostCalibrationComponentPassBase<
      TestPostCalibrationComponentPass>::TestPostCalibrationComponentPassBase;

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPostCalibrationComponentPass)

 private:
  void runOnOperation() override;
};

void TestPostCalibrationComponentPass::runOnOperation() {
  ModuleOp module_op = getOperation();

                                  quantfork::QuantizeCastOp>(ctx) {}
};

class QuantizePass : public impl::QuantizePassBase<QuantizePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizePass)

  using impl::QuantizePassBase<QuantizePass>::QuantizePassBase;

  explicit QuantizePass(const bool enable_per_channel_quantized_weight) {

    dequantize_op->moveAfter(passthrough_op);
    return success();
  }
};

struct OptimizeOpOrderPass
    : public impl::OptimizeOpOrderPassBase<OptimizeOpOrderPass> {
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OptimizeOpOrderPass)

  void runOnOperation() override;
};

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

    return success();
  }
};

class ReduceTypePrecisionPass
    : public impl::ReduceTypePrecisionPassBase<ReduceTypePrecisionPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ReduceTypePrecisionPass)
  void runOnOperation() override;
};

void ReduceTypePrecisionPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());