// CHECK-NEXT:        zero_point: [ 0 ]
  // CHECK-NEXT:       },
  // CHECK-NEXT:       has_rank: true
  // CHECK-NEXT:    }, {
  // CHECK-NEXT:      shape: [ 3 ],
  // CHECK-NEXT:      type: INT8,
  // CHECK-NEXT:      buffer: 3,
  // CHECK-NEXT:      name: "mul",
  // CHECK-NEXT:      quantization: {
  // CHECK-NEXT:        scale: [ 0.1 ],
  // CHECK-NEXT:        zero_point: [ 0 ]
  // CHECK-NEXT:       },

  // CHECK-NEXT:        zero_point: [ 0 ]
  // CHECK-NEXT:       },
  // CHECK-NEXT:       has_rank: true
  // CHECK-NEXT:    }, {
  // CHECK-NEXT:      shape: [ 3 ],
  // CHECK-NEXT:      type: INT8,
  // CHECK-NEXT:      buffer: 3,
  // CHECK-NEXT:      name: "mul",
  // CHECK-NEXT:      quantization: {
  // CHECK-NEXT:        scale: [ 1.0 ],
  // CHECK-NEXT:        zero_point: [ 0 ]
  // CHECK-NEXT:       },

    minbound = 0
    scale = (quant_max - quant_min) / maxbound
    zero_point = -quant_min / scale

    # Limit the range of zero_point and scale in case (quant_max - quant_min)
    # is unusually small.
    if abs(zero_point) > 9e9:
      zero_point = 9e9
    if abs(scale) < 1e-9:
      scale = 1e-9

    zero_point = round(zero_point)
    quantized_hist_mids = np.clip(

    return scale * rate;
  };
  const auto& recalculate_zero_point = [&](int64_t zero_point) -> int64_t {
    return qmax - std::round((storage_type_max - zero_point) / rate);
  };
  if (auto q_type = dyn_cast<UniformQuantizedType>(type)) {
    const double scale = recalculate_scale(q_type.getScale());
    const double zero_point = recalculate_zero_point(q_type.getZeroPoint());

# CHECK:         scale: [ 0.093635 ],
# CHECK:         zero_point: [ 22 ]
# CHECK:       }
# CHECK:     }, {
# CHECK:       shape: [ 1, 6, 31 ],
# CHECK:       type: INT8,
# CHECK:       buffer: 6,
# CHECK:       name: "output",
# CHECK:       quantization: {
# CHECK:         scale: [ 0.093635 ],
# CHECK:         zero_point: [ 22 ]
# CHECK:       }
# CHECK:     } ],
# CHECK:     inputs: [ 0 ],

  //   t[:, 1, :, :] will have scale[1]=2.0, zero_point[0]=2
  //   t[:, 2, :, :] will have scale[2]=3.0, zero_point[0]=3
  quantized_dimension:int;
}

// Sparse tensors.
// We use a modification of the TACO format.
// Reference: http://tensor-compiler.org/kjolstad-oopsla17-tensor-compiler.pdf
//
// To encode a conceptual n-dimensional dense tensor with dims (d0, ..., dn-1),

// Calculate the effective quantized value range for the scale, zero point. The
// range is the minimum range defined by [rmin, rmax] and [qmin, qmax].
QuantizedRange CalculateQuantizedRange(double scale, int32_t zero_point,
                                       std::optional<double> rmin,
                                       std::optional<double> rmax, int32_t qmin,
                                       int32_t qmax);

// CHECK-NEXT:      type: UINT16,
// CHECK-NEXT:      buffer: 1,
// CHECK-NEXT:      name: "arg0",
// CHECK-NEXT:      quantization: {
// CHECK-NEXT:        scale: [ 2.0 ],
// CHECK-NEXT:        zero_point: [ 37 ]
// CHECK:           }
// CHECK-NEXT:    } ],
  return %arg0 : tensor<*x!quant.uniform<u16:f32, 2.0:37>>

# CHECK:         scale: [ 0.093635 ],
# CHECK:         zero_point: [ 22 ]
# CHECK:       }
# CHECK:     }, {
# CHECK:       shape: [ 1, 6, 31 ],
# CHECK:       type: INT8,
# CHECK:       buffer: 6,
# CHECK:       name: "output",
# CHECK:       quantization: {
# CHECK:         scale: [ 0.093635 ],
# CHECK:         zero_point: [ 22 ]
# CHECK:       }
# CHECK:     } ],
# CHECK:     inputs: [ 0 ],

        input_tensor->quantization->zero_point.clear();
        input_tensor->quantization->min.push_back(-1.0);
        input_tensor->quantization->max.push_back(1.0);

        auto& output_tensor = sub_graph->tensors[op->outputs[0]];
        auto shape = output_tensor->shape;
        output_tensor->quantization->scale.clear();
        output_tensor->quantization->zero_point.clear();