// The node type when the model is exported. Currently this is limited to
  // DT_FLOAT, DT_HALF, DT_QINT8, and DT_QUINT8. When DT_HALF is used, the
  // `weight_quantization` flag needs to set to true. When DT_QUINT8 is used,
  // the `weight_quantization` flag needs to set to false.
  tensorflow::DataType inference_type = tensorflow::DT_FLOAT;

  // The input and output data type during inference. This flag is only used

    llvm::errs() << "Failed to get input quant spec.";
    return kTrFailure;
  }
  if (weight_quantization != "NONE") {
    quant_specs.weight_quantization = true;
    if (weight_quantization == "INT8") {
      quant_specs.inference_type = tensorflow::DT_QINT8;
    } else if (weight_quantization == "FLOAT16") {
      quant_specs.inference_type = tensorflow::DT_HALF;
    } else {

                        OpSet target_opset)
      : quant_specs_(quant_specs) {
    weight_quantization_ = quant_specs.weight_quantization;
    target_opset_ = target_opset;
  }

  QuantizePass(const QuantizePass& other) : quant_specs_(other.quant_specs_) {
    weight_quantization_ = other.weight_quantization_;
    target_opset_ = other.target_opset_;
  }

  StringRef getArgument() const final {

    enable_whole_model_verify_ = quant_specs.whole_model_verify;
    enable_legacy_quantize_ = quant_specs.legacy_float_scale;
    enable_dynamic_range_quantization_ = quant_specs.weight_quantization;
    enable_weight_only_quantization_ = quant_specs.weight_only_quantization;
  }

  void runOnOperation() override;

 private:
  quant::QuantizationSpecs quant_specs;
};

  PassManager pm((*module)->getName(), OpPassManager::Nesting::Implicit);
  quant::QuantizationSpecs quant_specs;
  quant_specs.inference_type = tflite::TflTypeToTfType(inference_type);
  quant_specs.weight_quantization = true;
  quant_specs.weight_only_quantization = weight_only_quantization;
  quant_specs.minimum_elements_for_weights = minimum_elements_for_weights;
  quant_specs.disable_per_channel = disable_per_channel;

  // quantization is enabled, `inference_type` and `inference_input_type` are
  // not used by MLIR passes.
  if (toco_flags.post_training_quantize()) {
    quant_specs->weight_quantization = true;
    quant_specs->disable_per_channel =
        toco_flags.disable_per_channel_quantization();
    if (toco_flags.quantize_to_float16()) {
      quant_specs->inference_type = DT_HALF;

  // 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;
    quant_specs_.enable_mlir_dynamic_range_quantizer = true;
  }

  // Constructor used by manually creating the pass.
  explicit PrepareDynamicRangeQuantizePass(

    return status_handler.Combine(
        absl::InternalError("Could not translate MLIR to FlatBuffer."));
  }

  // TODO: b/176267167 - Quantize flex fallback in the MLIR pipeline
  if (quant_specs.weight_quantization &&
      (!quant_specs.RunAndRewriteDynamicRangeQuantizationPasses() ||
       !pass_config.emit_builtin_tflite_ops)) {
    // Apply post-training dynamic range quantization from the old TOCO

        return success();
      }

      // Blocklist op is checked in advance for non-dynamic range quantization
      // case.
      if (!quant_params_.quant_spec.weight_quantization &&
          (ops_blocklist.find(quantizing_op->getName().getStringRef().str()) !=
           ops_blocklist.end())) {
        return failure();
      }

      if (!nodes_blocklist.empty()) {

    pm.addNestedPass<func::FuncOp>(CreatePostQuantizePass());
  } else {
    // Apply weight quantization.
    quant_specs.minimum_elements_for_weights = min_num_elements_for_weights_;
    quant_specs.weight_quantization = true;
    quant_specs.weight_only_quantization = enable_legacy_weight_only_;
    pm.addPass(CreatePrepareQuantizeDRQPass(quant_specs, target_opset_));
    pm.addNestedPass<func::FuncOp>(