<-ch
}

// Blows up a naive compiler.
func TestRaceNestedArrayCopy(t *testing.T) {
	ch := make(chan bool, 1)
	type (
		Point32   [2][2][2][2][2]Point
		Point1024 [2][2][2][2][2]Point32
		Point32k  [2][2][2][2][2]Point1024
		Point1M   [2][2][2][2][2]Point32k
	)
	var a, b Point1M
	go func() {
		a[0][1][0][1][0][1][0][1][0][1][0][1][0][1][0][1][0][1][0][1].y = 1
		ch <- true
	}()
	a = b

func fUint16(a uint16) uint16 { return a }

type TestUint16Alias uint16

func fUint16Alias(a TestUint16Alias) TestUint16Alias { return a }

func fUint32(a uint32) uint32 { return a }

type TestUint32Alias uint32

func fUint32Alias(a TestUint32Alias) TestUint32Alias { return a }

func fUint64(a uint64) uint64 { return a }

type TestUint64Alias uint64

	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[Txxx-0]
	_ = x[TINT8-1]
	_ = x[TUINT8-2]
	_ = x[TINT16-3]
	_ = x[TUINT16-4]
	_ = x[TINT32-5]
	_ = x[TUINT32-6]
	_ = x[TINT64-7]
	_ = x[TUINT64-8]
	_ = x[TINT-9]
	_ = x[TUINT-10]
	_ = x[TUINTPTR-11]
	_ = x[TCOMPLEX64-12]
	_ = x[TCOMPLEX128-13]
	_ = x[TFLOAT32-14]
	_ = x[TFLOAT64-15]
	_ = x[TBOOL-16]

// on 32-bit arch, don't use int64<->float conversion for uint32
var fpConvOpToSSA32 = map[twoTypes]twoOpsAndType{
	{types.TUINT32, types.TFLOAT32}: {ssa.OpCopy, ssa.OpCvt32Uto32F, types.TUINT32},
	{types.TUINT32, types.TFLOAT64}: {ssa.OpCopy, ssa.OpCvt32Uto64F, types.TUINT32},
	{types.TFLOAT32, types.TUINT32}: {ssa.OpCvt32Fto32U, ssa.OpCopy, types.TUINT32},
	{types.TFLOAT64, types.TUINT32}: {ssa.OpCvt64Fto32U, ssa.OpCopy, types.TUINT32},
}

// If the value passed in is not actually a map, this will panic.
func Int32KeySet[T any](theMap map[int32]T) Int32 {
	return Int32(KeySet(theMap))
}

// Insert adds items to the set.
func (s Int32) Insert(items ...int32) Int32 {
	return Int32(cast(s).Insert(items...))
}

// Delete removes all items from the set.
func (s Int32) Delete(items ...int32) Int32 {
	return Int32(cast(s).Delete(items...))

	"cmd/compile/internal/base"
	"cmd/internal/src"
)

var basicTypes = [...]struct {
	name  string
	etype Kind
}{
	{"int8", TINT8},
	{"int16", TINT16},
	{"int32", TINT32},
	{"int64", TINT64},
	{"uint8", TUINT8},
	{"uint16", TUINT16},
	{"uint32", TUINT32},
	{"uint64", TUINT64},
	{"float32", TFLOAT32},
	{"float64", TFLOAT64},
	{"complex64", TCOMPLEX64},
	{"complex128", TCOMPLEX128},
	{"bool", TBOOL},

	wfs := make([]obj.WasmField, len(abiParams))
	for i, p := range abiParams {
		t := p.Type
		switch t.Kind() {
		case types.TINT32, types.TUINT32:
			wfs[i].Type = obj.WasmI32
		case types.TINT64, types.TUINT64:
			wfs[i].Type = obj.WasmI64
		case types.TFLOAT32:
			wfs[i].Type = obj.WasmF32
		case types.TFLOAT64:
			wfs[i].Type = obj.WasmF64

      R"mlir(
      %0 = "tf.Const"() {value = #tf_type<tensor_proto : "0x746674656"> : tensor<1x3x2x2x!tf_type.qint32>} : () -> tensor<1x3x2x2x!tf_type.qint32>
      %1 = "tf.Const"() {value = #tf_type<tensor_proto : "0x746674656"> : tensor<2x!tf_type.qint32>} : () -> tensor<2x!tf_type.qint32>
      %2 = "tf.Const"() {value = dense<1.0> : tensor<f32>} : () -> tensor<f32>

// A Uint32 is an atomic uint32. The zero value is zero.
type Uint32 struct {
	_ noCopy
	v uint32
}

// Load atomically loads and returns the value stored in x.
func (x *Uint32) Load() uint32 { return LoadUint32(&x.v) }

// Store atomically stores val into x.
func (x *Uint32) Store(val uint32) { StoreUint32(&x.v, val) }

pkg sync/atomic, func OrUint64(*uint64, uint64) uint64 #61395
pkg sync/atomic, func OrUintptr(*uintptr, uintptr) uintptr #61395
pkg sync/atomic, method (*Int32) And(int32) int32 #61395
pkg sync/atomic, method (*Int32) Or(int32) int32 #61395
pkg sync/atomic, method (*Int64) And(int64) int64 #61395
pkg sync/atomic, method (*Int64) Or(int64) int64 #61395
pkg sync/atomic, method (*Uint32) And(uint32) uint32 #61395