MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPostCalibrationComponentPass)

 private:
  void runOnOperation() override;
};

void TestPostCalibrationComponentPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext& ctx = getContext();

  OpPassManager pm(ModuleOp::getOperationName());

  QuantizationConfig config = QuantizationConfig::default_instance();
  config.mutable_static_range_ptq_preset();

  // Erases the ops.
  for (auto op : erase_list) op->erase();
}

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

  for (auto init_func_op : GetInitializerFunctions(module_op)) {
    if (!init_func_op) return;

    if (init_func_op.getBlocks().size() != 1) {

}

}  // namespace

struct LegalizeStablehloToVhloPass
    : public impl::LegalizeStablehloToVhloPassBase<
          LegalizeStablehloToVhloPass> {
  void runOnOperation() override {
    ModuleOp module = getOperation();
    std::string target_version = tflite_supported_stablehlo_version;
    VhloToStablehloTypeConverter to_builtin_converter;

    // StableHLO --> VHLO (allow funcs)

                                             newConstOp);
  return success();
}

void ConvertConstPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto func = getOperation();
  auto *context = &getContext();
  patterns.add<QuantizedConstRewrite>(context);
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

std::unique_ptr<OperationPass<func::FuncOp>>

};

// 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,
                                        const StringAttr &op_device) {
    // In TFRT TPU, tensor transfer is handled specifically by D2H and

  if (!quantization_specs.ok()) {
    signalPassFailure();
    return;
  }

  pass_manager.addPass(
      CreateLiftQuantizableSpotsAsFunctionsPass(*quantization_specs));

  if (failed(pass_manager.run(getOperation()))) {
    signalPassFailure();
  }
}

}  // namespace

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

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

  patterns.add<ConvertTFBatchMatMulToEinsumOp<TF::BatchMatMulOp>,
               ConvertTFBatchMatMulToEinsumOp<TF::BatchMatMulV2Op>>(
      &getContext());

    enable_per_channel_quantized_weight_ = enable_per_channel_quantized_weight;
  }

 private:
  void runOnOperation() override;
};

void QuantizePass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext& ctx = getContext();

  RewritePatternSet patterns(&ctx);
  patterns.add<StableHloQuantization, StableHloQuantizationReverse>(&ctx);

  PopulateCommonQuantizationPatterns(ctx, patterns,

  YieldOp new_yield_op =
      CreateNewIslandYieldOp(new_island, island_operands_and_results.results);

  // Move inner ops from original islands into the new island.
  MoveInnerOpsToNewIsland(merged_island, new_yield_op.getOperation());

  // Update control inputs to point to the new merged island.
  for (IslandOp island : merged_island.islands)
    island.getControl().replaceAllUsesWith(new_island.getControl());

}

bool IsMhloUniformQuantizedOp(Operation& op) {
  return llvm::isa<mhlo::UniformQuantizeOp, mhlo::UniformDequantizeOp>(op);
}

void VerifyQuantLegalization::runOnOperation() {
  Operation* func_op = getOperation();

  auto walk_result = func_op->walk([&](Operation* op) {
    // Verify all uq and qint types are lowered.
    if (llvm::any_of(op->getOperandTypes(), IsQuantType) ||