return rewriter.notifyMatchFailure(op, "scales must be constant");
  }

  // Check whether the zero_points operand has constant op.
  DenseIntElementsAttr zero_points;
  if (!matchPattern(zero_points_value, m_Constant(&zero_points))) {
    return rewriter.notifyMatchFailure(op, "zero_points must be constant");
  }

  auto original_element_type = getElementTypeOrSelf(original_type);

)

_DebuggerConfig = stablehlo_quant_config_pb2.DebuggerConfig

# Lists of ops whose channel dimension should be changed if per_channel
# quantization is enabled. Respectively refers to (scale, zero_point).
_SUFFIXES = ('/filter1', '/filter2')
_PER_CHANNEL_OP_NAMES = (
    f'{op}{suffix}'
    for op, suffix in itertools.product(_PER_CHANNEL_QUANTIZED_OPS, _SUFFIXES)
)

      },
      "lang": {
        "type": "keyword"
      },
      "last_modified": {
        "type": "date",
        "format": "date_optional_time"
      },
      "location": {
        "type": "geo_point"
      },
      "mimetype": {
        "type": "keyword"
      },
      "parent_id": {
        "type": "keyword"
      },
      "role": {
        "type": "keyword"
      },
      "label": {

      },
      "lang": {
        "type": "keyword"
      },
      "last_modified": {
        "type": "date",
        "format": "date_optional_time"
      },
      "location": {
        "type": "geo_point"
      },
      "mimetype": {
        "type": "keyword"
      },
      "parent_id": {
        "type": "keyword"
      },
      "role": {
        "type": "keyword"
      },
      "label": {

      },
      "lang": {
        "type": "keyword"
      },
      "last_modified": {
        "type": "date",
        "format": "date_optional_time"
      },
      "location": {
        "type": "geo_point"
      },
      "mimetype": {
        "type": "keyword"
      },
      "parent_id": {
        "type": "keyword"
      },
      "role": {
        "type": "keyword"
      },
      "label": {

      quant_type = UniformQuantizedType::getChecked(
          const_op->getLoc(), quant::QuantizationFlags::Signed,
          rewriter.getIntegerType(16), attr.getType().getElementType(), scale,
          /*zeroPoint=*/0, llvm::minIntN(10), -llvm::minIntN(10));
    } else {
      quant_type = mlir::dyn_cast<quant::UniformQuantizedType>(
          quant::GetUniformQuantizedTypeForWeight(
              attr, /*symmetric=*/true,

LogicalResult VerifyScalesAndZeroPoints(UniformQuantizedOp op, Value scales,
                                        Value zero_points,
                                        int32_t quantization_axis) {
  ShapedType scales_type = scales.getType().cast<ShapedType>();
  ShapedType zero_points_type = zero_points.getType().cast<ShapedType>();

  if (quantization_axis == -1) {
    if (scales_type.hasRank() && scales_type.getRank() != 0) {

  auto mul_op = builder.create<TF::MulOp>(loc, zp, reduced);

  SmallVector<Value> folded_results = ConstantFoldOpIfPossible(mul_op);
  return folded_results.front();
}

// Add two contributions, and a zeropoint modification term
// Consider two quantized matrices P, Q with zero points z, w. Let's say the
// dimensions are l X n, n X m.
// What we want to calculate is: R = matmul(P-z, Q-w).

  // expected-error @below {{'tf.UniformQuantizedDotHybrid' op quantization_axis is -1, zero_points must have 0 rank.}}
  %0 = "tf.UniformQuantizedDotHybrid"(%lhs, %rhs, %rhs_scales, %rhs_zps) {
    rhs_quantization_axis = -1 : i64, rhs_quantization_min_val = -128 : i64, rhs_quantization_max_val = 127 : i64