a4 = Int8 * int8(1000)       // ERROR "overflow|cannot convert"
	a5 = int8(Int8 * 1000)       // ERROR "overflow|cannot convert"
	a6 = int8(Int8 * int8(1000)) // ERROR "overflow|cannot convert"
	a7 = Int8 - 2*Int8 - 2*Int8  // ERROR "overflow|cannot convert"
	a8 = Int8 * Const / 100      // ERROR "overflow|cannot convert"
	a9 = Int8 * (Const / 100)    // OK

	{id: "foo", typ: "<type 1 []<type -1>>", want: "[]int8"},
	{id: "foo", typ: "<type 1 [42]<type -1>>", want: "[42]int8"},
	{id: "foo", typ: "<type 1 map [<type -1>] <type -2>>", want: "map[int8]int16"},
	{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 chan -< <type -1>>", want: "chan<- int8"},

type RawSockaddrUnix struct {
	Family uint16
	Path   [108]int8
}

type RawSockaddrDatalink struct {
	Family uint16
	Index  uint16
	Type   uint8
	Nlen   uint8
	Alen   uint8
	Slen   uint8
	Data   [244]int8
}

type RawSockaddr struct {
	Family uint16
	Data   [14]int8
}

type RawSockaddrAny struct {
	Addr RawSockaddr
	Pad  [236]int8
}

type _Socklen uint32

	if x1 == x2 {
		panic("bad comparison")
	}

	a1 := [2]int8{-1, 88}
	a2 := [2]int8{-1, 99}
	if a1 == a2 {
		panic("bad comparison")
	}
	b1 := [4]int8{-1, 88, 88, 88}
	b2 := [4]int8{-1, 99, 99, 99}
	if b1 == b2 {
		panic("bad comparison")
	}
	c1 := [8]int8{-1, 88, 88, 88, 88, 88, 88, 88}
	c2 := [8]int8{-1, 99, 99, 99, 99, 99, 99, 99}
	if c1 == c2 {
		panic("bad comparison")
	}

	F_asyncwrites uint64
	F_asyncreads  uint64
	F_fsid        Fsid
	F_namemax     uint32
	F_owner       uint32
	F_ctime       uint64
	F_fstypename  [16]int8
	F_mntonname   [90]int8
	F_mntfromname [90]int8
	F_mntfromspec [90]int8
	Pad_cgo_0     [2]byte
	Mount_info    [160]byte
}

type Flock_t struct {
	Start  int64
	Len    int64
	Pid    int32
	Type   int16
	Whence int16
}

	F_asyncwrites uint64
	F_asyncreads  uint64
	F_fsid        Fsid
	F_namemax     uint32
	F_owner       uint32
	F_ctime       uint64
	F_fstypename  [16]int8
	F_mntonname   [90]int8
	F_mntfromname [90]int8
	F_mntfromspec [90]int8
	Pad_cgo_1     [2]byte
	Mount_info    [160]byte
}

type Flock_t struct {
	Start  int64
	Len    int64
	Pid    int32
	Type   int16
	Whence int16
}

func main() {
	chki8(int8(i8), ci8&0xff-1<<8)
	chki8(int8(i16), ci16&0xff)
	chki8(int8(i32), ci32&0xff-1<<8)
	chki8(int8(i64), ci64&0xff)
	chki8(int8(u8), cu8&0xff-1<<8)
	chki8(int8(u16), cu16&0xff)
	chki8(int8(u32), cu32&0xff)
	chki8(int8(u64), cu64&0xff)
	//	chki8(int8(f32), 0)
	//	chki8(int8(f64), 0)

	chki16(int16(i8), ci8&0xffff-1<<16)

	F_asyncwrites uint64
	F_asyncreads  uint64
	F_fsid        Fsid
	F_namemax     uint32
	F_owner       uint32
	F_ctime       uint64
	F_fstypename  [16]int8
	F_mntonname   [90]int8
	F_mntfromname [90]int8
	F_mntfromspec [90]int8
	Pad_cgo_1     [2]byte
	Mount_info    [160]byte
}

type Flock_t struct {
	Start  int64
	Len    int64
	Pid    int32
	Type   int16
	Whence int16
}

	if (int64(int16(sx)) == sx || int64(int16(^sx)) == ^sx) && (int64(int16(sy)) == sy || int64(int16(^sy)) == ^sy) {
		checkint16(int16(sx), int16(sy))
	}
	if (int64(int8(sx)) == sx || int64(int8(^sx)) == ^sx) && (int64(int8(sy)) == sy || int64(int8(^sy)) == ^sy) {
		checkint8(int8(sx), int8(sy))
	}
}

// Check result of x/y, x%y for various types.

func checkuint(x, y uint) {
	if y == 0 {
		divzerouint(x, y)

		fmt.Printf("f3(...) = %v, wanted 254\n", got)
		failed = true
	}
	if failed {
		panic("bad")
	}
}

func f1(a1 uint, a2 int8, a3 int8, a4 int8, a5 uint8, a6 int, a7 bool) uint8 {
	a5--
	a4 += (a2 << a1 << 2) | (a4 ^ a4<<(a1&a1)) - a3                              // int8
	a6 -= a6 >> (2 + uint32(a2)>>3)                                              // int