clEnumValN(OpSet::TF, "TF",
                     "Uses TF ops that mimic quantization behavior"),
          clEnumValN(OpSet::XLA, "XLA", "Uses TF XLA ops"),
          clEnumValN(OpSet::UNIFORM_QUANTIZED, "UNIFORM_QUANTIZED",
                     "Uses TF Uniform Quantized ops"))};

  // Initialize for tests.
  void initializeForTest() {
    if (!test_mode_) return;

          clEnumValN(OpSet::TF, "TF",
                     "Uses TF ops that mimic quantization behavior"),
          clEnumValN(OpSet::XLA, "XLA", "Uses TF XLA ops"),
          clEnumValN(OpSet::UNIFORM_QUANTIZED, "UNIFORM_QUANTIZED",
                     "Uses TF Uniform Quantized ops"))};
};

bool QuantizePass::shouldKeepUnusedQdqPattern() {
  return target_opset_ == OpSet::XLA &&

  // Constructor used by the PassRegistration and enforce int8 quantization.
  // This is only used by test.
  explicit PrepareQuantizeDRQPass() : op_set_(OpSet::UNIFORM_QUANTIZED) {
    quant_specs_.inference_type = tensorflow::DT_QINT8;
  }

  // Constructor used by manually creating the pass.
  explicit PrepareQuantizeDRQPass(const QuantizationSpecs& quant_specs,

  // Uses TF ops that mimic quantization behavior. Used when the corresponding
  // integer op is not yet present.
  TF = 1;
  // Uses TF XLA ops
  XLA = 2;
  // Uses TF Uniform Quantized ops
  UNIFORM_QUANTIZED = 3;
  // Uses the StableHLO Quantizer. StableHLO Quantizer will be available as
  // an option in the TF Quantizer in StableHLO Quantizer v1.
  STABLEHLO = 4;
}

    quantization_options.enable_per_channel_quantization = False

  if quantization_options.enable_per_channel_quantization and not (
      (
          quantization_options.op_set == quant_opts_pb2.OpSet.UNIFORM_QUANTIZED
          or quantization_options.quantization_method.preset_method
          == _PresetMethod.METHOD_STATIC_RANGE_WEIGHT_ONLY_INT8
      )
      or (
          quantization_options.op_set

      quantization_options.mutable_quantization_method()->set_preset_method(
          quantization::QuantizationMethod::METHOD_DYNAMIC_RANGE_INT8);
      quantization_options.set_op_set(quantization::UNIFORM_QUANTIZED);
      quantization_options.set_min_num_elements_for_weights(
          kWeightsMinNumElementsDefault);
      quantization::AddQuantizePtqDynamicRangePasses(pass_manager,

        UniformQuantizeFunctionCallPattern::Match(uniform_quantize_call_op);
    if (failed(uniform_quantize_call_pattern_for_input)) {
      LLVM_DEBUG(llvm::dbgs()
                 << "Failed to match uniform_quantized call op for input.\n");
      return failure();
    }

    // Match the subgraph that receives the convolution output.
    Value conv_output_value = op.getResult();
    if (auto output_element_type =