// MethodB has a blank receiver type parameter. 
	func (t Type[_]) MethodB()

	// MethodC has a lower-case receiver type parameter. 
	func (t Type[c]) MethodC()

	// int16 shadows the predeclared type int16. 

		println("int8-4", bn2, bd2, bn2/bd2, bn2%bd2)
		panic("fail")
	}

	/* int16 */
	var sn1 int16 = +5
	var sn2 int16 = -5
	var sd1 int16 = +3
	var sd2 int16 = -3

	if sn1/sd1 != q1 || sn1%sd1 != r1 {
		println("int16-1", sn1, sd1, sn1/sd1, sn1%sd1)
		panic("fail")
	}
	if sn2/sd1 != q2 || sn2%sd1 != r2 {
		println("int16-2", sn2, sd1, sn2/sd1, sn2%sd1)
		panic("fail")
	}

package main

func main() {
	v1 := [2]int32{-1, 88}
	v2 := [2]int32{-1, 99}
	if v1 == v2 {
		panic("bad comparison")
	}

	w1 := [2]int16{-1, 88}
	w2 := [2]int16{-1, 99}
	if w1 == w2 {
		panic("bad comparison")
	}
	x1 := [4]int16{-1, 88, 88, 88}
	x2 := [4]int16{-1, 99, 99, 99}
	if x1 == x2 {
		panic("bad comparison")
	}

	a1 := [2]int8{-1, 88}
	a2 := [2]int8{-1, 99}
	if a1 == a2 {

	if (int64(int32(sx)) == sx || int64(int32(^sx)) == ^sx) && (int64(int32(sy)) == sy || int64(int32(^sy)) == ^sy) {
		checkint32(int32(sx), int32(sy))
	}
	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))
	}

	tebw := embedwrap{teb, &teb}

	testCases := []struct {
		a    interface{}
		want string
	}{
		{int8(93), "(int8) 93\n"},
		{int16(93), "(int16) 93\n"},
		{int32(93), "(int32) 93\n"},
		{int64(93), "(int64) 93\n"},
		{int(-93), "(int) -93\n"},
		{int8(-93), "(int8) -93\n"},
		{int16(-93), "(int16) -93\n"},
		{int32(-93), "(int32) -93\n"},
		{int64(-93), "(int64) -93\n"},
		{uint(93), "(uint) 93\n"},
		{uint8(93), "(uint8) 93\n"},

	{id: "foo", typ: "<type 1 (? <type -1>) <type -2>>", want: "func(int8) int16"},
}

func TestTypeParser(t *testing.T) {
	for _, test := range typeParserTests {
		var p parser
		p.init("test.gox", strings.NewReader(test.typ), make(map[string]*types.Package))
		p.version = "v2"

)

const (
	_ int16 = minInt16 /* ERROR "overflows" */ - 1
	_ int16 = minInt16
	_ int16 = maxInt16
	_ int16 = maxInt16 /* ERROR "overflows" */ + 1
	_ int16 = smallestFloat64 /* ERROR "truncated" */

	_ = int16(minInt16 /* ERROR "overflows" */ - 1)
	_ = int16(minInt16)
	_ = int16(maxInt16)
	_ = int16(maxInt16 /* ERROR "overflows" */ + 1)
	_ = int16(smallestFloat64 /* ERROR "cannot convert" */)
)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

var (
	_ = int8(1 /* ERROR "constant 255 overflows int8" */ <<8 - 1)
	_ = int16(1 /* ERROR "constant 65535 overflows int16" */ <<16 - 1)
	_ = int32(1 /* ERROR "constant 4294967295 overflows int32" */ <<32 - 1)
	_ = int64(1 /* ERROR "constant 18446744073709551615 overflows int64" */ <<64 - 1)

// for literal lengths. RFC 3.1.1.3.2.2.1.
var literalPredefinedDistribution = []int16{
	4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
	2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
	-1, -1, -1, -1,
}

// offsetPredefinedDistribution is the predefined distribution table
// for offsets. RFC 3.1.1.3.2.2.3.
var offsetPredefinedDistribution = []int16{
	1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,

}

type Uint8 uint8

func (x Uint8) m(a, b, c, d, e, f, g, h byte) {
	check("Uint8", int64(x), 0x01, a, b, c, d, e, f, g, h)
}

type Int16 int16

func (x Int16) m(a, b, c, d, e, f, g, h byte) {
	check("Int16", int64(x), 0x0102, a, b, c, d, e, f, g, h)
}

type Uint16 uint16

func (x Uint16) m(a, b, c, d, e, f, g, h byte) {
	check("Uint16", int64(x), 0x0102, a, b, c, d, e, f, g, h)
}