llvm::SmallVector<Value, 4> quantized;
      for (auto user : returned.getUsers()) {
        if (auto q = Quantized(user)) {
          quantized.push_back(q);
        }
      }
      if (quantized.size() == 1) {
        ret.setOperand(i, quantized.front());
      }
      i++;
    }
  });

  // Check for  (Quant (Dequant $in), $qA) "qdq" pairs that couldn't be

    // previous quantized layer (Please note that this part is different part
    // from DEBUGGER_TYPE_FLOAT_PER_LAYER). Each layer in the debugging model
    // has a DumpTensor, and it is used to save the entire value of outputs from
    // both the quantized and unquantized layer.
    DEBUGGER_TYPE_INT_PER_LAYER = 2;
    // DEBUGGER_TYPE_FLOAT_PER_LAYER creates a debugging model with both

    assert(scales_.size() == zero_points_.size());
  }

  // Quantize an Attribute by the quantization parameters. Return nullptr if
  // the conversion fails or the input array isn't an ElementsAttr.
  ElementsAttr convert(Attribute real_value);

 private:
  // Quantize an DenseFPElementsAttr by the quantization parameters.
  DenseElementsAttr convert(DenseFPElementsAttr attr);

// The prepare-dynamic-range-quantize Pass.
//
namespace mlir {
namespace TFL {

namespace {
#define GEN_PASS_DEF_PREPAREDYNAMICRANGEQUANTIZEPASS
#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

// A boolean attribute used to describe whether input activations need to be
// asymmetrically quantized.
constexpr char kAsymmetricQuantizeInputsAttr[] = "asymmetric_quantize_inputs";

      llvm::SmallVector<Value, 4> quantized;
      for (auto user : returned.getUsers()) {
        if (auto q = Quantized(user)) {
          quantized.push_back(q);
        }
      }
      if (quantized.size() == 1) {
        ret.setOperand(i, quantized.front());
      }
      i++;
    }
  });

  // We prefer to placing quantization emulation ops on the results of the

// Returns element type from attribute Type 'type_attr'.
mlir::Type GetShapeStrippedType(mlir::TypeAttr type_attr);

// Returns true if 'val' is not from Quantize op or
// from Quantize Op with same quant type as 'qtype_attr'
bool NotFromQuantOpOrSameQuantType(mlir::Value val, mlir::TypeAttr qtype_attr);

}  // namespace tflite

                            << quantized_per_axis_type << ".\n");
    return false;
  }

  return true;
}

// Determines whether the storage type of a quantized type is supported by
// `tfl.quantize` or `tfl.dequantize` ops. ui8, i8 and i16 are supported.
bool IsSupportedByTfliteQuantizeOrDequantizeOps(IntegerType storage_type) {
  if (storage_type.getWidth() == 8 ||

    // the textual format (on the commandline for example).
    return "quant-propagate-quantize-type";
  }
  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Propagate quantized type through allowed ops.";
  }

  void runOnOperation() override;
};

// Propagate dequantize op if the next op supports the data type.
// Given the below graph,

        /*value=*/filter_i8_value_attr);

    // Replace filter uses with uniform quantized filter.
    rewriter.replaceAllUsesWith(filter_op->getResult(0),
                                quantized_filter_constant_op.getResult());

    // Replace conv op with a new convolution op that has quantized output type.
    // Quantize -> Dequantize following r3.
    auto output_uniform_quantize_call_op = cast<func::CallOp>(

  auto func_op = module_op->lookupSymbol<func::FuncOp>("quantize");
  ASSERT_THAT(func_op, NotNull());

  auto uniform_quantize_op_itr =
      func_op.getBody().op_begin<mlir::stablehlo::UniformQuantizeOp>();
  ASSERT_THAT(
      uniform_quantize_op_itr,
      Ne(func_op.getBody().op_end<mlir::stablehlo::UniformQuantizeOp>()));

  // `uniform_quantize` is considered partially quantized because its output is