t.a = uint16(x)
	t.b = uint16(x >> 16)
}

type T8 struct {
	a, b uint8
}

//go:noinline
func (t *T8) bigEndianLoad() uint16 {
	return uint16(t.a)<<8 | uint16(t.b)
}

//go:noinline
func (t *T8) littleEndianLoad() uint16 {
	return uint16(t.a) | (uint16(t.b) << 8)
}

//go:noinline
func (t *T8) bigEndianStore(x uint16) {
	t.a = uint8(x >> 8)
	t.b = uint8(x)
}

)

//sys	RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW
//sys	DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource

	AuthFlags       uint32
	FullName        *uint16
	UsrComment      *uint16
	Parms           *uint16
	Workstations    *uint16
	LastLogon       uint32
	LastLogoff      uint32
	AcctExpires     uint32
	MaxStorage      uint32
	UnitsPerWeek    uint32
	LogonHours      *byte
	BadPwCount      uint32
	NumLogons       uint32
	LogonServer     *uint16
	CountryCode     uint32
	CodePage        uint32

)

type binaryByteOrder interface {
	Uint16([]byte) uint16
	Uint32([]byte) uint32
	Uint64([]byte) uint64
	PutUint16([]byte, uint16)
	PutUint32([]byte, uint32)
	PutUint64([]byte, uint64)
}

type binaryLittleEndian struct{}

func (binaryLittleEndian) Uint16(b []byte) uint16 {
	_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
	return uint16(b[0]) | uint16(b[1])<<8
}

	SubstituteNameLength uint16
	// PrintNameOffset is similar to SubstituteNameOffset.
	PrintNameOffset uint16
	// PrintNameLength is similar to SubstituteNameLength.
	PrintNameLength uint16
	// Flags specifies whether the substitute name is a full path name or
	// a path name relative to the directory containing the symbolic link.
	Flags      uint32
	PathBuffer [1]uint16
}

// Path returns path stored in rb.

func Encode(s []rune) []uint16 {
	n := len(s)
	for _, v := range s {
		if v >= surrSelf {
			n++
		}
	}

	a := make([]uint16, n)
	n = 0
	for _, v := range s {
		switch RuneLen(v) {
		case 1: // normal rune
			a[n] = uint16(v)
			n++
		case 2: // needs surrogate sequence
			r1, r2 := EncodeRune(v)
			a[n] = uint16(r1)
			a[n+1] = uint16(r2)
			n += 2
		default:

	mc_fs            uint16
	mc_gs            uint16
	mc_addr          uint64
	mc_flags         uint32
	mc_es            uint16
	mc_ds            uint16
	mc_err           uint64
	mc_rip           uint64
	mc_cs            uint64
	mc_rflags        uint64
	mc_rsp           uint64
	mc_ss            uint64
	mc_len           uint64
	mc_fpformat      uint64
	mc_ownedfp       uint64
	mc_fpstate       [64]uint64

// symbol is found.
func (t *huffmanTree) Decode(br *bitReader) (v uint16) {
	nodeIndex := uint16(0) // node 0 is the root of the tree.

	for {
		node := &t.nodes[nodeIndex]

		var bit uint16
		if br.bits > 0 {
			// Get next bit - fast path.
			br.bits--
			bit = uint16(br.n>>(br.bits&63)) & 1
		} else {
			// Get next bit - slow path.
			// Use ReadBits to retrieve a single bit

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

			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)