// conversion, then dequantized during inference.
    // Activation: f32, Weight: qi8, Bias: f32
    WEIGHT_ONLY = 1;

    // Apply default dynamic range quantization. Quantized tensor value's
    // ranges are determined during graph runtime.
    // Activation: f32, Weight: qi8, Bias: f32
    POST_TRAINING_QUANTIZATION_DYNAMIC_RANGE = 2;

  let arguments = (
    ins TFL_TensorOf<[F32, QI8, QI16]>:$input,

    // Weights
    TFL_TensorOfOrNone<[F32, QI8]>:$input_to_input_weights,
    TFL_TensorOf<[F32, QI8]>:$input_to_forget_weights,
    TFL_TensorOf<[F32, QI8]>:$input_to_cell_weights,
    TFL_TensorOf<[F32, QI8]>:$input_to_output_weights,

    // Recurrent weights
    TFL_TensorOfOrNone<[F32, QI8]>:$recurrent_to_input_weights,

      {"I32", "32-bit signless integer"},
      {"I64", "64-bit signless integer"},
      {"QI16", "QI16 type"},
      {"I8", "8-bit signless integer"},
      {"UI8", "8-bit unsigned integer"},
      {"QI8", "QI8 type"},
      {"QUI8", "QUI8 type"},
      {"TFL_Quint8", "TFLite quint8 type"},
  });

  return *entries;
}

void EmitDynamicRangeOp(std::vector<Record *> &defs, raw_ostream *ostream) {

    $quant_input,
    $bias, $padding, $stride_h, $stride_w, $faf),
  (TFL_TransposeConvOp $output_shape, $quant_weights,
    $quant_input, $bias, $padding, $stride_h, $stride_w, $faf), 

      return true;
  }
  // Check quantized types.
  if (auto quant_type = element_type.dyn_cast<mlir::quant::QuantizedType>()) {
    // TFLite supports QI16, QI32, QI8, and QUI8
    if ((quant_type.getStorageTypeIntegralWidth() == 16 &&
         quant_type.isSigned()) ||
        quant_type.getStorageTypeIntegralWidth() == 8 ||
        (quant_type.getStorageTypeIntegralWidth() == 32 &&

//
// StableHLO Quantizer output:
//   * input: per-tensor qi8
//   * filter: per-channel qi8 for non-batching op, per-tensor for batching op.
//   * output: per-tensor qi32
// JAX Quantizer output:
//   * input: per-tensor qi8
//   * filter: per-channel qi8
//   * output: per-tensor qi8
//
// Conditions for the `tfl.batch_matmul` conversion:

inline bool IsF32ShapedType(Type t) {
  if (auto shaped_type = mlir::dyn_cast_or_null<ShapedType>(t)) {
    return shaped_type.getElementType().isF32();
  }
  return false;
}

// Return true when the given element_type is QI8.
inline bool IsQI8Type(Type t) {
  auto quantized_type = quant::QuantizedType::getQuantizedElementType(t);
  return quantized_type != nullptr &&
         quantized_type.getStorageTypeIntegralWidth() == 8 &&

// General uniform quantized types. The definitions can be used to specify
// operand's tensor types.
def QI4 : QuantizedType<"Uniform", [4], 1>;
def QUI8 : QuantizedType<"Uniform", [8], 0>;
def QI8 : QuantizedType<"Uniform", [8], 1>;
def QUI16 : QuantizedType<"Uniform", [16], 0>;
def QI16 : QuantizedType<"Uniform", [16], 1>;
def QUI32 : QuantizedType<"Uniform", [32], 0>;
def QI32 : QuantizedType<"Uniform", [32], 1>;

00000000  14 03 03 00 01 01 16 03  03 00 40 00 00 00 00 00  |..........@.....|
00000010  00 00 00 00 00 00 00 00  00 00 00 4a bf f1 2b 6a  |...........J..+j|
00000020  af e5 b9 51 69 38 3e a3  47 bf 0b 67 83 15 e0 91  |...Qi8>.G..g....|
00000030  c6 b3 cb fc 24 05 31 b7  51 3d fa bb 08 9a f9 f8  |....$.1.Q=......|
00000040  89 2a f1 5a b1 a8 1a ed  aa 63 00 17 03 03 00 40  |.*.Z.....c.....@|

      continue;
    }

    if (broadcast_args_pivot != parent_broadcast_args) {
      return false;
    }
  }
  return true;
}

// Return true when the given element_type is QI8.
bool IsQI8Type(Type element_type) {
  auto quantized_type = element_type.dyn_cast<QuantizedType>();
  return quantized_type != nullptr &&
         quantized_type.getStorageTypeIntegralWidth() == 8 &&