} else if (auto aqtype = qtype.template dyn_cast<
                             quant::UniformQuantizedPerAxisType>()) {
      auto zero_points = aqtype.getZeroPoints();
      llvm::SmallVector<int64_t, 4> new_zero_points(zero_points.begin(),
                                                    zero_points.end());
      for (int i = 0, e = new_zero_points.size(); i < e; ++i) {
        new_zero_points[i] -= offset;
      }

    auto result_type = getOutput().getType();
    // central_value = min_value / 2 + (max_value - 1) / 2 + 1
    // zero_point = central_value
    // scale = 1. / (central_value - min_value)
    return quant::GetFixedOutputRange(is_signed, bit_width, result_type,
        /*scale=*/1.0 / (1<<(bit_width-1)), /*zero_point=*/0);
  }
  }];
}

def TFL_LeakyReluOp: TFL_Op<"leaky_relu", [
    SameOperandsAndResultShape,

// uniform_dequantize functions. Returns `failure()` if it doesn't match.
LogicalResult MatchZeroPointsOperand(Value zero_points) {
  if (!zero_points) {
    LLVM_DEBUG(llvm::dbgs() << "Zero point value is empty.\n");
    return failure();
  }

  auto zero_points_type =
      mlir::dyn_cast_or_null<TensorType>(zero_points.getType());
  if (!zero_points_type) {

// If the input `tensor` has scale/zero_point, `res` should have quantized
// type, thus none stats op is required and nullptr is returned.
// If the min max information is invalid, nullptr is returned.
mlir::Operation* ConvertMinMaxToStatsOp(const TensorT& tensor, OpBuilder b,
                                        Value res) {
  // If the `tensor` has scale/zero_point, it must have been quantized, then the

    const double result_scale = input_scale * filter_scale;

    accumulation_quantized_element_type = CreateI32F32UniformQuantizedType(
        gemm_style_op->getLoc(), *rewriter.getContext(), result_scale,
        /*zero_point=*/0);

    new_gemm_style_op_result_type = gemm_style_op_result_type.cloneWith(
        gemm_style_shape, accumulation_quantized_element_type);
  }

  gemm_style_op_result.setType(new_gemm_style_op_result_type);

  { auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } else { _o->zero_point.resize(0); } }
  { auto _e = details_type(); _o->details.type = _e; }

  let summary = "Perform dequantization on the quantized Tensor `input`.";

  let description = [{
Given quantized `input` which was quantized using `scales` and `zero_points`, performs dequantization using the formula:
dequantized_data = (quantized_data - zero_point) * scale.
  }];

  let arguments = (ins
    Arg<TensorOf<[TF_Qint32, TF_Qint8]>, [{Must be a Tensor of Tin.}]>:$input,

    std::vector<float> scales = {static_cast<float>(qtype.getScale())};
    std::vector<int64_t> zero_points = {qtype.getZeroPoint()};
    q_params = tflite::CreateQuantizationParameters(
        builder_, /*min=*/0, /*max=*/0, builder_.CreateVector<float>(scales),
        builder_.CreateVector<int64_t>(zero_points));
  } else if (auto qtype = mlir::dyn_cast<mlir::quant::CalibratedQuantizedType>(
                 element_type)) {

// template argument list.
template <unsigned BitWidth, int ZeroPoint, int ScaleMantissa, int ScaleExp,
          int64_t StorageTypeMin, int64_t StorageTypeMax, bool Sign>
class FixedResultUniformScale {
 public:
  template <typename ConcreteType>
  class Impl
      : public QuantizationSpecTraitBase<
            ConcreteType, FixedResultUniformScale<
                              BitWidth, ZeroPoint, ScaleMantissa, ScaleExp,

  SmallVector<double, 4> scales;
  SmallVector<int64_t, 4> zeroPoints;
  scales.reserve(axisSize);
  zeroPoints.reserve(axisSize);
  for (size_t axis = 0; axis != axisSize; ++axis) {
    double rmin = rmins[axis];
    double rmax = rmaxs[axis];
    if (std::fabs(rmax - rmin) < std::numeric_limits<double>::epsilon()) {
      scales.push_back(1.0);
      zeroPoints.push_back(qmin);
      continue;
    }