},
	},
	modifier{
		name: "structT",
		t: func() {
			s := newStructT()
			for i := 0; i < mods; i++ {
				s.u8++
				s.u16++
				s.u32++
				s.u64++
				s.i8++
				s.i16++
				s.i32++
				s.i64++
				s.f32 *= 1.01
				s.f64 *= 1.01
				s.c64 = complex(real(s.c64)*1.01, imag(s.c64)*1.01)
				s.c128 = complex(real(s.c128)*1.01, imag(s.c128)*1.01)
				s.b++
				s.r++

  // CHECK: value = dense<[1, 2, 3, 4]> : tensor<4xi8>
  %0 = "tfl.pseudo_const" () { value = dense<[1, 2, 3, 4]> : tensor<4xi8> } : () -> tensor<4xi8>
  func.return %0 : tensor<4xi8>
}

func.func @i16() -> tensor<4xi16> {
  // CHECK-LABEL: @i16
  // CHECK: value = dense<[1, 2, 3, 258]> : tensor<4xi16>
  %0 = "tfl.pseudo_const" () { value = dense<[1, 2, 3, 258]> : tensor<4xi16> } : () -> tensor<4xi16>
  func.return %0 : tensor<4xi16>
}

bool IsI32F32UniformQuantizedPerAxisType(Type type);

// Determines whether the storage type of a quantized type is supported by
// `tfl.quantize` or `tfl.dequantize` ops. ui8, i8 and i16 are supported.
bool IsSupportedByTfliteQuantizeOrDequantizeOps(IntegerType storage_type);

// Returns true if a type is quantized tensor type.
bool IsQuantizedTensorType(Type type);

		t.Fatalf("want %q, got %q", want, got)
	}
}

func TestDebugLogTypes(t *testing.T) {
	skipDebugLog(t)
	runtime.ResetDebugLog()
	var varString = strings.Repeat("a", 4)
	runtime.Dlog().B(true).B(false).I(-42).I16(0x7fff).U64(^uint64(0)).Hex(0xfff).P(nil).S(varString).S("const string").End()
	got := dlogCanonicalize(runtime.DumpDebugLog())
	if want := "[] true false -42 32767 18446744073709551615 0xfff 0x0 aaaa const string\n"; got != want {

  auto elemType = getElementTypeOrSelf(type);
  // F16, F32, F64, BF16 types are allowed.
  if (elemType.isBF16() || elemType.isF16() || elemType.isF32() ||
      elemType.isF64())
    return true;

  // I1, I4, I8, I16, I32, I64 types are allowed.
  if (elemType.isInteger(1) || elemType.isInteger(4) || elemType.isInteger(8) ||
      elemType.isInteger(16) || elemType.isInteger(32) ||
      elemType.isInteger(64))
    return true;

include "mlir/Dialect/Tensor/IR/TensorOps.td"
include "stablehlo/dialect/ChloOps.td"
include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.td"
include "mhlo/IR/hlo_ops.td"

def SignedIntTensor : TensorOf<[I1, I8, I16, I32, I64]>;
def UnsignedIntTensor : TensorOf<[UI8, UI16, UI32, UI64]>;

// IEEE compliant floating point tensors.
def IEEEFloatTensor : TensorOf<[F16, F32, F64]>;

		{name: "Econstflt", fn: func() { e = 99.0 }}, // constants do not allocate
		{name: "Econststr", fn: func() { e = "change" }},
		{name: "I8", fn: func() { i1 = eight8I }},
		{name: "I16", fn: func() { i1 = zero16I }},
		{name: "I32", fn: func() { i1 = zero32I }},
		{name: "I64", fn: func() { i1 = zero64I }},
		{name: "Istr", fn: func() { i1 = zerostrI }},
		{name: "Islice", fn: func() { i1 = zerosliceI }},

    %12 = "mhlo.compare"(%arg1, %arg3) {comparison_direction = #mhlo<comparison_direction LT>} : (tensor<i16>, tensor<i16>) -> tensor<i1>
    %13 = "mhlo.select"(%12, %arg1, %arg3) : (tensor<i1>, tensor<i16>, tensor<i16>) -> tensor<i16>
    %14 = "mhlo.compare"(%arg1, %arg3) {comparison_direction = #mhlo<comparison_direction EQ>} : (tensor<i16>, tensor<i16>) -> tensor<i1>

		a := int16(rand.Uint32())
		a >>= uint(rand.Intn(16))
		if -a != a {
			return a
		}
	}
	return 0 // impossible
}

func i16test(a, b, c int16) {
	d := a % c
	if d != b {
		println("i16", a, b, c, d)
		panic("fail")
	}
}

func i16run() {
	var a, b int16

	for i := 0; i < Count; i++ {
		a = i16rand()

		b = a % 1
		i16test(a, b, 1)
		b = a % 2
		i16test(a, b, 2)

		a := int16(rand.Uint32())
		a >>= uint(rand.Intn(16))
		if -a != a {
			return a
		}
	}
	return 0 // impossible
}

func i16test(a, b, c int16) {
	d := a / c
	if d != b {
		println("i16", a, b, c, d)
		panic("fail")
	}
}

func i16run() {
	var a, b int16

	for i := 0; i < Count; i++ {
		a = i16rand()

		b = a / 1
		i16test(a, b, 1)
		b = a / 2
		i16test(a, b, 2)