(Arith_ConstantOp:$multiplier F32ElementsAttr:$mul_value)),
// TODO(karimnosseir): Add check for $conv is of rank 4.
      (TF_Conv2DOp $input,
          (TF_MulOp (Arith_ConstantOp $filter_value, (location $filter)),
                    (Arith_ConstantOp $mul_value, (location $multiplier)),
                    (location $mul)),

    }
    filter_value = filter.getValue();
    mul_value = multiplier.getValue();
    // In MHLO, Conv filter is in HWIO format, Depthwise conv filter is in HW1O
    // format and backprop input conv filter is in HWOI format.
    // Only fuses multiplier if all dimensions other than the out channel
    // dimension are equal to 1.
    if (!TFL::IsDimensionsDegenerateExceptLastOne(
            mul_value.getShapedType().getShape())) {

// Calculates the number of bins from the range and bin width.
inline int32_t CalculateActualNumBins(const float min_value,
                                      const float max_value,
                                      const float bin_width) {
  const float lower_bound = CalculateLowerBound(min_value, bin_width);
  return std::ceil((max_value - lower_bound) / bin_width);
}

TEST(CalibrationParametersTest, CalculateBinWidthSmallerThanOne) {

      mse_min = min(mse_tuple, mse_min)
    # Extract (quant_min, quant_max) from (mse_error, quant_min, quant_max).
    min_value, max_value = mse_min[1], mse_min[2]
    return min_value, max_value


@_implements(_CalibrationMethod.CALIBRATION_METHOD_MIN_MAX)
class _MinMax(_CalibrationAlgorithmBase):

    statistics.min_max_statistics.global_min = 1.0
    statistics.min_max_statistics.global_max = 5.0

    min_value, max_value = calibration_algorithm.get_min_max_value(
        statistics, calib_opts
    )
    self.assertAllEqual((min_value, max_value), (1.0, 5.0))

  def test_average_min_max(self):
    calib_opts = stablehlo_quant_config_pb2.CalibrationOptions(

namespace mlir {
namespace TFL {

template <class TFFakeQuantOp>
struct FetchMinMaxAttrs {
  using AttrType = FloatAttr;
  bool operator()(TFFakeQuantOp tf_op, AttrType &min_value,
                  AttrType &max_value) const {
    min_value = tf_op.getMinAttr();
    max_value = tf_op.getMaxAttr();
    return true;  // Successfully matched and fetched.
  }
};

template <class TFFakeQuantOp>
struct FetchConstantMinMaxInputs {

namespace mlir {
namespace quant {

template <class TFFakeQuantOp>
struct FetchMinMaxAttrs {
  using AttrType = FloatAttr;
  bool operator()(TFFakeQuantOp tf_op, AttrType &min_value,
                  AttrType &max_value) const {
    min_value = tf_op.getMinAttr();
    max_value = tf_op.getMaxAttr();
    return true;  // Successfully matched and fetched.
  }
};

template <class TFFakeQuantOp>
struct FetchConstantMinMaxInputs {

            new long[] {},
            new long[] {MIN_VALUE},
            new long[] {MIN_VALUE, MIN_VALUE},
            new long[] {MIN_VALUE, (long) 1},
            new long[] {(long) 1},
            new long[] {(long) 1, MIN_VALUE},
            new long[] {MAX_VALUE, MAX_VALUE - (long) 1},
            new long[] {MAX_VALUE, MAX_VALUE},
            new long[] {MAX_VALUE, MAX_VALUE, MAX_VALUE});

    }
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    try {
      MathPreconditions.checkPositive("int", Integer.MIN_VALUE);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCheckPositive_positiveInt() {

        0                 | 0x1ff
        0x2ff             | 0x1000
        0x1000            | -1
        Integer.MAX_VALUE | -1
        Long.MAX_VALUE    | -1
        Long.MAX_VALUE    | -0xc3412
        Integer.MAX_VALUE | Integer.MIN_VALUE
        Long.MAX_VALUE    | Long.MIN_VALUE
    }

    def "decode fails when small long cannot be fully read"() {
        given: