package testcase

type C interface{ ~uint | ~uint32 | ~uint64 }

func isAligned[T C](x, y T) bool { // ERROR "can inline isAligned\[uint\]" "can inline isAligned\[go\.shape\.uint\]" "inlining call to isAligned\[go\.shape\.uint\]"
	return x%y == 0
}

func foo(x uint) bool { // ERROR "can inline foo"
	return isAligned(x, 64) // ERROR "inlining call to isAligned\[go\.shape\.uint\]"

Status TensorInterface::ToTensor(tensorflow::Tensor* dst) const {
  *dst = tensor_;
  return absl::OkStatus();
}

bool TensorInterface::IsAligned() const { return tensor_.IsAligned(); }

}  // namespace tensorflow

  // Return size in bytes of the Tensor
  virtual size_t ByteSize() const = 0;
  // Returns a pointer to tensor data
  virtual void* Data() const = 0;

  // Returns if the tensor is aligned
  virtual bool IsAligned() const = 0;
  // Returns if their is sole ownership of this Tensor and thus it can be moved.
  virtual bool CanMove() const = 0;

  virtual std::string SummarizeValue() const = 0;

 protected:

  int NumDims() const override;
  int64_t Dim(int dim_index) const override;
  int64_t NumElements() const override;
  size_t ByteSize() const override;
  void* Data() const override;
  bool IsAligned() const override;
  bool CanMove() const override;
  std::string SummarizeValue() const override;

  void SetShape(const int64_t* dims, int num_dims);
  Status ToTensor(tensorflow::Tensor* dst) const;

                                     const bool narrow_range,
                                     const bool is_signed) {
  if (num_bits >= 8) {
    return type;
  }
  int64_t qmin = QType::getDefaultMinimumForInteger(is_signed, num_bits);
  int64_t qmax = QType::getDefaultMaximumForInteger(is_signed, num_bits);
  if (narrow_range) {
    qmin += 1;
  }
  const int64_t storage_type_min = type.getStorageTypeMin();

        storage_bit_width_(storage_bit_width),
        is_signed_(is_signed),
        round_mode_(APFloat::rmNearestTiesToAway) {}

  UniformQuantizedValueConverter(double scale, double zero_point,
                                 const APFloat& clamp_min,
                                 const APFloat& clamp_max,
                                 uint32_t storage_bit_width, bool is_signed)
      : scale_(scale),
        zero_point_(zero_point),

  ConvertStatsToQDQs(int num_bits, bool narrow_range, bool is_signed,
                     bool legacy_float_scale, MLIRContext* context)
      : OpRewritePattern<quantfork::StatisticsOp>(context),
        num_bits(num_bits),
        narrow_range(narrow_range),
        is_signed(is_signed),
        legacy_float_scale(legacy_float_scale) {}

            /*narrowRange=*/true, expressed,
            /*isSigned=*/true);
      } else {
        quant_type = quantfork::fakeQuantAttrsToType(
            op.getLoc(), tensor_property.number_of_bits, min, max,
            /*narrowRange=*/false, expressed,
            /*isSigned=*/true);
      }
      if (quant_specs_.legacy_float_scale) {

}

tensorflow::DataType GetQuantizedInferenceType(bool is_signed,
                                               int number_of_bits) {
  if (is_signed && number_of_bits == 8) {
    return tensorflow::DT_QINT8;
  } else if (!is_signed && number_of_bits == 8) {
    return tensorflow::DT_QUINT8;
  } else if (is_signed && number_of_bits == 16) {
    return tensorflow::DT_QINT16;
  } else {

                                                 bool isSigned) {
  MLIRContext *ctx = expressedType.getContext();
  unsigned flags = isSigned ? quant::QuantizationFlags::Signed : 0;
  Type storageType;
  int64_t qmin;
  int64_t qmax;
  if (getDefaultStorageParams(numBits, narrowRange, isSigned, ctx, storageType,
                              qmin, qmax)) {