}
}

func si3c(c <-chan int16) {
	// amd64:"CMPW\t.+, [$]256"
	// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255"
	for x := <-c; x >= 0 && x < 256; x = <-c {
	}
}

func si4c(c <-chan int8) {
	// amd64:"CMPB\t.+, [$]10"
	// s390x:"CLIJ\t[$]4, R[0-9]+, [$]10"
	for x := <-c; x >= 0 && x < 10; x = <-c {
	}
}

func si5c(c <-chan int64) {
	// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"

	e
)

var x = []int{1, 2, 3}

func f(x int, len *byte) {
	*len = byte(x)
}

func whatis(x interface{}) string {
	switch xx := x.(type) {
	default:
		return fmt.Sprint("default ", xx)
	case int, int8, int16, int32:
		return fmt.Sprint("signed ", xx)
	case int64:
		return fmt.Sprint("signed64 ", int64(xx))
	case uint, uint8, uint16, uint32:
		return fmt.Sprint("unsigned ", xx)
	case uint64:

		// constraint, so we can use == here.
		if v == x {
			return i
		}
	}
	return -1
}

type obj struct {
	x int
}

type obj2 struct {
	x int8
	y float64
}

type obj3 struct {
	x int64
	y int8
}

type inner struct {
	y int64
	z int32
}

type obj4 struct {
	x int32
	s inner
}

func main() {
	want := 2

	vec1 := []string{"ab", "cd", "ef"}

package pointer

	"runtime"
)

type quad struct { x, y, z, w int }

const (
	cj = 100011
	ci int = 100012
	ci8 int8 = 115
	ci16 int16 = 10016
	ci32 int32 = 100013
	ci64 int64 = 100014
	ci64big int64 = 1<<31
	ci64bigger int64 = 1<<32
	chuge = 1<<100
	cfgood = 2.0
	cfbad = 2.1

	cnj = -2
	cni int = -3
	cni8 int8 = -6
	cni16 int16 = -7
	cni32 int32 = -4
	cni64 int64 = -5
	cni64big int64 = -1<<31

		},
		mapPointerKeyT: func() {
			a := make(map[*int8]int8)
			for i := 0; i < length; i++ {
				a[new(int8)] = int8(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan int8)
			for i := 0; i < mods; i++ {
				go func() { a <- int8(i) }()
				<-a
				runtime.Gosched()
			}

package main

func f1(a []int64, i int64) int64 {
	return a[i+1<<30]
}
func f2(a []int32, i int64) int32 {
	return a[i+1<<30]
}
func f3(a []int16, i int64) int16 {
	return a[i+1<<30]
}
func f4(a []int8, i int64) int8 {
	return a[i+1<<31]
}
func f5(a []float64, i int64) float64 {
	return a[i+1<<30]
}
func f6(a []float32, i int64) float32 {
	return a[i+1<<30]
}

}

func CheckPtrStringFail() {
	p := new(byte)
	sink2 = p
	sink2 = unsafe.String(p, 100)
}

func CheckPtrAlignmentNested() {
	s := make([]int8, 100)
	p := unsafe.Pointer(&s[0])
	n := 9
	_ = ((*[10]int8)(unsafe.Pointer((*[10]int64)(unsafe.Pointer(&p)))))[:n:n]

		Data: unsafe.Pointer(&b[0]),
		Len:  n,
		Cap:  cap(b) * int(scale),
	}
	return *(*[]int8)(unsafe.Pointer(&s))
}
func (c *Cache) freeInt8Slice(s []int8) {
	var base int64
	var derived int8
	scale := unsafe.Sizeof(base) / unsafe.Sizeof(derived)
	b := unsafeheader.Slice{
		Data: unsafe.Pointer(&s[0]),
		Len:  int((uintptr(len(s)) + scale - 1) / scale),
		Cap:  int((uintptr(cap(s)) + scale - 1) / scale),

	},
	{struct {
		x struct {
			a int8
			b int8
			c int8
			d int32
		}
	}{},
		"struct { a int8; b int8; c int8; d int32 }",
	},
	{struct {
		x struct {
			a int8
			b int8
			c int8
			d int8
			e int32
		}
	}{},
		"struct { a int8; b int8; c int8; d int8; e int32 }",
	},
	{struct {
		x struct {
			a int8
			b int8
			c int8