class PrepareQuantizePass
    : public impl::PrepareQuantizePassBase<PrepareQuantizePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PrepareQuantizePass)

  // Constructor used by the PassRegistration and enforce uint8 quantization.
  // This is only used by test.
  explicit PrepareQuantizePass() : use_quantization_flags_(true) {}

  // Constructor used by manually creating the pass.

    : public impl::PrepareDynamicRangeQuantizePassBase<
          PrepareDynamicRangeQuantizePass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PrepareDynamicRangeQuantizePass)

  // Constructor used by the PassRegistration. This is only used by test.
  explicit PrepareDynamicRangeQuantizePass() {
    quant_specs_.inference_type = tensorflow::DT_QINT8;
    quant_specs_.weight_quantization = true;

        "your original model plans");
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreatePickSubgraphsPass() {
  return std::make_unique<PickSubgraphsPass>();
}

static PassRegistration<PickSubgraphsPass> pass;

}  // namespace tac
}  // namespace TFL

    std::optional<ModuleOp> tfr_module, bool materialize_derived_attrs) {
  return std::make_unique<RaiseToTFOpsPass>(tfr_module,
                                            materialize_derived_attrs);
}

static PassRegistration<RaiseToTFOpsPass> pass([] {
  return CreateRaiseToTFOpsPass();
});

}  // namespace TFR

      return signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> createOptimizePass() {
  return std::make_unique<OptimizePass>();
}

static PassRegistration<OptimizePass> pass;

}  // namespace odml

    return sym_name.starts_with(kQuantizedFuncPrefix) ||
           sym_name.starts_with(kCompositeFuncPrefix);
  }

  ModuleOp module_;
  SymbolTable symbol_table_;
};

static PassRegistration<QuantizeCompositeFunctionsPass> pass;

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

void QuantizeCompositeFunctionsPass::runOnOperation() {

}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>
CreateReplaceCastHacksWithTFXLAOpsPass() {
  return std::make_unique<ReplaceCastHacksWithTFXLAOpsPass>();
}

static PassRegistration<ReplaceCastHacksWithTFXLAOpsPass> pass;

  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateComposeUniformQuantizedTypePass() {
  return std::make_unique<ComposeUniformQuantizedTypePass>();
}

static PassRegistration<ComposeUniformQuantizedTypePass> pass;

}  // namespace odml

}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>
CreateUniformQuantizedStableHloToTflPass() {
  return std::make_unique<UniformQuantizedStableHloToTflPass>();
}

static PassRegistration<UniformQuantizedStableHloToTflPass> pass;

}  // namespace odml

  populateWithGenerated(*patterns);
}

std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeHloToTfPass() {
  return std::make_unique<LegalizeHloToTf>();
}

static PassRegistration<LegalizeHloToTf> pass;

}  // end namespace odml