panic("u32 != ju32")
	}
	if u64 != iu64 {
		panic("u64 != iu64")
	}
	if u64 != ju64 {
		panic("u64 != ju64")
	}
	if u128 != iu128 {
		panic("u128 != iu128")
	}
	if u128 != ju128 {
		panic("u128 != ju128")
	}
	if f32 != if32 {
		panic("f32 != if32")
	}
	if f32 != jf32 {
		panic("f32 != jf32")
	}
	if f64 != if64 {
		panic("f64 != if64")
	}
	if f64 != jf64 {

		case tf64*100 + ti16:
			f64 = float64(v); i16 = int16(f64); w = big(i16)
		case tf64*100 + tu16:
			f64 = float64(v); u16 = uint16(f64); w = big(u16)
		case tf64*100 + ti32:
			f64 = float64(v); i32 = int32(f64); w = big(i32)
		case tf64*100 + tu32:
			f64 = float64(v); u32 = uint32(f64); w = big(u32)
		case tf64*100 + ti64:
			f64 = float64(v); i64 = int64(f64); w = big(i64)
		case tf64*100 + tu64:

	s := Sprintf("%v %v %v %v %v", TI(0), TI8(1), TI16(2), TI32(3), TI64(4))
	check(t, s, "I: 0 I8: 1 I16: 2 I32: 3 I64: 4")
	s = Sprintf("%v %v %v %v %v %v", TU(5), TU8(6), TU16(7), TU32(8), TU64(9), TUI(10))
	check(t, s, "U: 5 U8: 6 U16: 7 U32: 8 U64: 9 UI: 10")
	s = Sprintf("%v %v %v", TF(1.0), TF32(2.0), TF64(3.0))
	check(t, s, "F: 1.000000 F32: 2.000000 F64: 3.000000")
	s = Sprintf("%v %v", TB(true), TS("x"))
	check(t, s, "B: true S: \"x\"")

func cvt11(a float32) int {
	return int(a)
}

//go:noinline
func cvt12(a float32) uint {
	return uint(a)
}

//go:noinline
func f2i64p(v float64) *int64 {
	return ip64(int64(v / 0.1))
}

//go:noinline
func ip64(v int64) *int64 {
	return &v
}

func TestFloatConvert(t *testing.T) {
	if got := cvt1(3.5); got != 3 {
		t.Errorf("cvt1 got %d, wanted 3", got)
	}

	i32 := types.Types[types.TINT32]
	i64 := types.Types[types.TINT64]
	f32 := types.Types[types.TFLOAT32]
	f64 := types.Types[types.TFLOAT64]
	c64 := types.Types[types.TCOMPLEX64]
	c128 := types.Types[types.TCOMPLEX128]
	ft := mkFuncType(nil,
		[]*types.Type{
			i8, i16, i32, i64,
			f32, f32, f64, f64,
			i8, i16, i32, i64,
			f32, f32, f64, f64,
			c128, c128, c128, c128, c64,
			i8, i16, i32, i64,

  %0 = mhlo.constant dense<1.000000e+00> : tensor<f64>
  %1 = mhlo.convert %0 : (tensor<f64>) -> tensor<i64>
  %2 = mhlo.reshape %1 : (tensor<i64>) -> tensor<1xi64>
  // expected-error @+1 {{Node `mhlo.dynamic_iota` must have compile-time constant}}
  %3 = "mhlo.dynamic_iota"(%2) <{iota_dimension = 0 : i64}> : (tensor<1xi64>) -> tensor<?xi32>
  %4 = mhlo.multiply %3, %3 : tensor<?xi32>

        expect:
        arch.name == name
        arch.i386 == i386
        arch.amd64 == amd64
        arch.ia64 == ia64
        arch.arm == arm || arm64
        arch.arm32 == arm
        arch.arm64 == arm64

        where:
        name        | i386  | amd64 | ia64  | arm   | arm64
        "x86"       | true  | false | false | false | false
        "x86-64"    | false | true  | false | false | false

  func.return %0#0 : tensor<*xf32>
}

// CHECK-LABEL: @RewriteSendRecvOps

  }

  // CHECK-LABEL: multiple_return_values
  func.func @multiple_return_values(%arg0: tensor<3xi64>) -> tensor<i64> {
     %0:3 = "tf.Unpack"(%arg0) {axis = 0 : i64} : (tensor<3xi64>) -> (tensor<i64>, tensor<i64>, tensor<i64>)
    // CHECK: return %1 : tensor<i64>
    func.return %0#0 : tensor<i64>
  }

  // CHECK-LABEL: constant_parameter
  func.func @constant_parameter(%arg0: tensor<2xf32>) -> tensor<2xf32> {

  // CHECK: arith.index_cast {{.*}} : index to i64
  // CHECK: arith.cmpi eq, {{.*}} : i64
  // CHECK: arith.addi {{.*}} : i64
  // CHECK: tensor.dim {{.*}} : tensor<4xi32>
  // CHECK: arith.index_cast {{.*}} : index to i64
  // CHECK: select {{.*}} : i64
  // CHECK: arith.index_cast {{.*}} : i64 to index
  // CHECK: arith.index_cast {{.*}} : i64 to index
  // CHECK: tensor.from_elements {{.*}} : tensor<1xindex>