_ = 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)

	_ = uint8(1 /* ERROR "constant 256 overflows uint8" */ << 8)
	_ = uint16(1 /* ERROR "constant 65536 overflows uint16" */ << 16)

		}
		extOff = int(nativeEndian.Uint16(b[18:20]))
		bodyOff = int(nativeEndian.Uint16(b[16:18]))
	} else {
		extOff = w.extOff
		bodyOff = w.bodyOff
	}
	if len(b) < extOff || len(b) < bodyOff {
		return nil, errInvalidMessage
	}
	l := int(nativeEndian.Uint16(b[:2]))
	if len(b) < l {
		return nil, errInvalidMessage
	}
	attrs := uint(nativeEndian.Uint32(b[4:8]))
	if attrs&syscall.RTA_IFP == 0 {

package windows

type WSAData struct {
	Version      uint16
	HighVersion  uint16
	MaxSockets   uint16
	MaxUdpDg     uint16
	VendorInfo   *byte
	Description  [WSADESCRIPTION_LEN + 1]byte
	SystemStatus [WSASYS_STATUS_LEN + 1]byte
}

type Servent struct {
	Name    *byte
	Aliases **byte
	Proto   *byte
	Port    uint16
}

type JOBOBJECT_BASIC_LIMIT_INFORMATION struct {

package windows

type WSAData struct {
	Version      uint16
	HighVersion  uint16
	Description  [WSADESCRIPTION_LEN + 1]byte
	SystemStatus [WSASYS_STATUS_LEN + 1]byte
	MaxSockets   uint16
	MaxUdpDg     uint16
	VendorInfo   *byte
}

type Servent struct {
	Name    *byte
	Aliases **byte
	Port    uint16
	Proto   *byte
}

type JOBOBJECT_BASIC_LIMIT_INFORMATION struct {

}

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)
}

			lo = i
		}
	}
	return
}

func to16(x []uint32) []uint16 {
	var y []uint16
	for _, v := range x {
		if uint32(uint16(v)) != v {
			panic("bad 32->16 conversion")
		}
		y = append(y, uint16(v))
	}
	return y
}

func main() {
	flag.Parse()

	rang, except := scan(0, 0xFFFF)
	range16 = to16(rang)
	except16 = to16(except)
	range32, except32 = scan(0x10000, unicode.MaxRune)

		Type:    int(b[3]),
		Flags:   int(nativeEndian.Uint32(b[16:20])),
		Index:   int(nativeEndian.Uint16(b[6:8])),
		ID:      uintptr(nativeEndian.Uint32(b[24:28])),
		Seq:     int(nativeEndian.Uint32(b[28:32])),
		raw:     b[:l],
	}
	ll := int(nativeEndian.Uint16(b[4:6]))
	if len(b) < ll {
		return nil, errInvalidMessage
	}
	errno := syscall.Errno(nativeEndian.Uint32(b[32:36]))
	if errno != 0 {
		m.Err = errno
	}

// Issue 1011.  Removing either #1 or #3 avoided the crash at #2.

package main

import (
	"io"
	"strings"
)

func readU16BE(b []byte) uint16 {
	b[0] = 0
	b[1] = 1
	return uint16(b[0])<<8 + uint16(b[1]) // #1
	n := uint16(b[0])<<8 + uint16(b[1])
	return n
}

func readStr(r io.Reader, b []byte) string {
	n := readU16BE(b)
	if int(n) > len(b) {
		return "err: n>b"
	}

	assert(-(i35+1) == i36, "i35")
	assert(i33 == (1<<63)-1, "i33 size")

	// uint8
	var u00 uint8 = 0
	var u01 uint8 = 1
	var u02 uint8 = 255
	var u03 uint8 = +255
	assert(u01 == u00+1, "u01")
	assert(u02 == u03, "u02")
	assert(u03 == (1<<8)-1, "u03 size")

	// uint16
	var u10 uint16 = 0
	var u11 uint16 = 1
	var u12 uint16 = 65535
	var u13 uint16 = +65535
	assert(u11 == u10+1, "u11")
	assert(u12 == u13, "u12")

package main

func main() {
	Decode[int16](nil)
	Decode[uint16](nil)
	Decode[float64](nil)
}

func DecodeInt16(b []byte) (int16, int) {
	return 0, 0
}

func DecodeUint16(b []byte) (uint16, int) {
	return 0, 0
}

func DecodeFloat64(b []byte) (float64, int) {
	return 0, 0
}

func Decode[T any](b []byte) (T, int) {
	switch any(*new(T)).(type) {
	case int16:
		v, n := DecodeInt16(b)