}

// CHECK-LABEL: testAddInt16
func.func @testAddInt16(tensor<? x i16>, tensor<? x i16>) -> tensor<? x i16> {
^bb0(%arg0: tensor<? x i16>, %arg1: tensor<? x i16>):
  // CHECK: tfl.add %arg0, %arg1 {fused_activation_function = "RELU6"}
  %0 = tfl.add %arg0, %arg1 {fused_activation_function = "RELU6"} : tensor<? x i16>
  func.return %0#0 : tensor<? x i16>
}

// CHECK-LABEL: testSub

	{id: "foo", typ: "<type 1 chan <- <type -1>>", want: "<-chan int8"},
	{id: "foo", typ: "<type 1 chan -< <type -1>>", want: "chan<- int8"},
	{id: "foo", typ: "<type 1 struct { I8 <type -1>; I16 <type -2> \"i16\"; }>", want: "struct{I8 int8; I16 int16 \"i16\"}"},

			lo = i
		}
	}
	return
}

func to16(x []uint32) []uint16 {
	var y []uint16
	for _, v := range x {
		if uint32(uint16(v)) != v {
			panic("bad 32->16 conversion")
		}
		y = append(y, uint16(v))
	}
	return y
}

func main() {
	flag.Parse()

	rang, except := scan(0, 0xFFFF)
	range16 = to16(rang)
	except16 = to16(except)
	range32, except32 = scan(0x10000, unicode.MaxRune)

var Dlog = dlog

func (l *dlogger) End()                  { l.end() }
func (l *dlogger) B(x bool) *dlogger     { return l.b(x) }
func (l *dlogger) I(x int) *dlogger      { return l.i(x) }
func (l *dlogger) I16(x int16) *dlogger  { return l.i16(x) }
func (l *dlogger) U64(x uint64) *dlogger { return l.u64(x) }
func (l *dlogger) Hex(x uint64) *dlogger { return l.hex(x) }
func (l *dlogger) P(x any) *dlogger      { return l.p(x) }

		t.Errorf("float64(u8) != du8")
	}
	if float64(i64) != di64 {
		t.Errorf("float64(i64) != di64")
	}
	if float64(i32) != di32 {
		t.Errorf("float64(i32) != di32")
	}
	if float64(i16) != di16 {
		t.Errorf("float64(i16) != di16")
	}
	if float64(i8) != di8 {
		t.Errorf("float64(i8) != di8")
	}
	if float32(u64) != su64 {
		t.Errorf("float32(u64) != su64")
	}
	if float32(u32) != su32 {

    Results are always sorted in the descending order.
  }];

  let arguments = (ins
    TFL_TensorOf<[F32, I8, I16, I32, I64, UI8, QI8, QUI8]>:$input,
    TFL_TensorOf<[I16, I32]>:$k);

  let results = (outs
    TFL_TensorOf<[F32, I8, I16, I32, I64, UI8, QI8, QUI8]>:$values,
    TFL_TensorOf<[I16, I32]>:$indices);

  let builders = [
    OpBuilder<(ins "Value":$input, "Value":$k),

    %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>

		isZeros(ip[0:10]) &&
		ip[10] == 0xff &&
		ip[11] == 0xff {
		return ip[12:16]
	}
	return nil
}

// To16 converts the IP address ip to a 16-byte representation.
// If ip is not an IP address (it is the wrong length), To16 returns nil.
func (ip IP) To16() IP {
	if len(ip) == IPv4len {
		return IPv4(ip[0], ip[1], ip[2], ip[3])
	}
	if len(ip) == IPv6len {
		return ip
	}
	return nil

var i0 int
var i1 int
var i2 int
var i3 int
var i4 int
var i5 int
var i6 int
var i7 int
var i8 int
var i9 int
var i10 int
var i11 int
var i12 int
var i13 int
var i14 int
var i15 int
var i16 int

func main() {
	var f0 float32 = 0.0
	var f1 float32 = 1.0
	var f2 float32 = 2.0
	var f3 float32 = 3.0
	var f4 float32 = 4.0
	var f5 float32 = 5.0
	var f6 float32 = 6.0
	var f7 float32 = 7.0

)

// linearMax is the maximum size table for linear search for non-Latin1 rune.
// Derived by running 'go test -calibrate'.
const linearMax = 18

// is16 reports whether r is in the sorted slice of 16-bit ranges.
func is16(ranges []Range16, r uint16) bool {
	if len(ranges) <= linearMax || r <= MaxLatin1 {
		for i := range ranges {
			range_ := &ranges[i]
			if r < range_.Lo {
				return false
			}