let description = [{
    Interface for defining the fixed output range.
  }];

  let methods = [
    InterfaceMethod<
      [{Returns the fixed output range.}],
      "UniformQuantizedType", "GetFixedOutputRange",
      (ins "bool":$sign, "int":$bit_width)
    >,
  ];
}

def AffineQuantizedOpInterface : OpInterface<
  "AffineQuantizedOpInterface"> {
  let description = [{

}

quant::UniformQuantizedType GetFixedOutputRange(const bool is_signed,
                                                const int bit_width,
                                                const Type tensor_type,
                                                const double scale,
                                                const int64_t zero_point) {
  return GetFixedOutputRange(is_signed, bit_width, tensor_type, scale,

    std::function<QuantizedType(const std::vector<QuantizedType>&, int, bool)>;
using BiasParamsMap =
    absl::flat_hash_map<int, std::pair<std::vector<int>, AccumulatorScaleFunc>>;
// UniformQuantizedType GetFixedOutputRange(bool sign, int bit_width)
using GetFixedOutputRangeFunc = std::function<UniformQuantizedType(bool, int)>;
// bool RequiredSameOperandsAndResultsScale(bool sign, int $bit_width)

  // FixedOutputRangeInterface:
  quant::UniformQuantizedType GetFixedOutputRange(
      bool is_signed, int bit_width) {
    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,