SizeofIPv6MTUInfo      = 0x20
	SizeofMsghdr           = 0x30
	SizeofCmsghdr          = 0xc
	SizeofICMPv6Filter     = 0x20
)

const (
	SizeofIfMsghdr = 0x10
)

type IfMsgHdr struct {
	Msglen  uint16
	Version uint8
	Type    uint8
	Addrs   int32
	Flags   int32
	Index   uint16
	Addrlen uint8
	_       [1]byte
}

type FdSet struct {
	Bits [1024]int64
}

pkg syscall (freebsd-arm64), type IfaMsghdr struct, Index uint16
pkg syscall (freebsd-arm64), type IfaMsghdr struct, Metric int32
pkg syscall (freebsd-arm64), type IfaMsghdr struct, Msglen uint16
pkg syscall (freebsd-arm64), type IfaMsghdr struct, Pad_cgo_0 [2]uint8
pkg syscall (freebsd-arm64), type IfaMsghdr struct, Type uint8
pkg syscall (freebsd-arm64), type IfaMsghdr struct, Version uint8

pkg syscall (darwin-arm64), type IfMsghdr struct, Flags int32
pkg syscall (darwin-arm64), type IfMsghdr struct, Index uint16
pkg syscall (darwin-arm64), type IfMsghdr struct, Msglen uint16
pkg syscall (darwin-arm64), type IfMsghdr struct, Pad_cgo_0 [2]uint8
pkg syscall (darwin-arm64), type IfMsghdr struct, Type uint8
pkg syscall (darwin-arm64), type IfMsghdr struct, Version uint8

pkg syscall (freebsd-riscv64), type IfAnnounceMsghdr struct #53466
pkg syscall (freebsd-riscv64), type IfAnnounceMsghdr struct, Index uint16 #53466
pkg syscall (freebsd-riscv64), type IfAnnounceMsghdr struct, Msglen uint16 #53466
pkg syscall (freebsd-riscv64), type IfAnnounceMsghdr struct, Name [16]int8 #53466
pkg syscall (freebsd-riscv64), type IfAnnounceMsghdr struct, Type uint8 #53466

		{"IfmaMsghdr.Index", Field, 0},
		{"IfmaMsghdr.Msglen", Field, 0},
		{"IfmaMsghdr.Pad_cgo_0", Field, 0},
		{"IfmaMsghdr.Type", Field, 0},
		{"IfmaMsghdr.Version", Field, 0},
		{"IfmaMsghdr2", Type, 0},
		{"IfmaMsghdr2.Addrs", Field, 0},
		{"IfmaMsghdr2.Flags", Field, 0},
		{"IfmaMsghdr2.Index", Field, 0},
		{"IfmaMsghdr2.Msglen", Field, 0},
		{"IfmaMsghdr2.Pad_cgo_0", Field, 0},

			src := make([]byte, tt.srcLen)
			if tt.srcLen >= 2 {
				src[1] = 42
			}
			dst := js.Global().Get("Uint8Array").New(tt.dstLen)

			if got, want := js.CopyBytesToJS(dst, src), tt.copyLen; got != want {
				t.Errorf("copied %d, want %d", got, want)
			}
			if tt.dstLen >= 2 {
				if got, want := dst.Index(1).Int(), 42; got != want {
					t.Errorf("got %d, want %d", got, want)

	if _, err := s.sr.Seek(0, io.SeekStart); err != nil {
		return nil, err
	}
	var stlen uint32
	var stoff uint64
	var nsyms uint32
	var symoff uint64
	switch f.TargetMachine {
	case U802TOCMAGIC:
		lhdr := new(LoaderHeader32)
		if err := binary.Read(s.sr, binary.BigEndian, lhdr); err != nil {
			return nil, err
		}
		stlen = lhdr.Lstlen
		stoff = uint64(lhdr.Lstoff)
		nsyms = lhdr.Lnsyms
		symoff = LDHDRSZ_32

		argLen: 0,
		reg:    regInfo{},
	},
	{
		name:   "FlagGT_UGT",
		argLen: 0,
		reg:    regInfo{},
	},
	{
		name:   "FlagGT_ULT",
		argLen: 0,
		reg:    regInfo{},
	},
	{
		name:    "MOVSSconst1",
		auxType: auxFloat32,
		argLen:  0,
		reg: regInfo{
			outputs: []outputInfo{
				{0, 239}, // AX CX DX BX BP SI DI
			},
		},
	},
	{

package rand

/*
 * Uniform distribution
 *
 * algorithm by
 * DP Mitchell and JA Reeds
 */

const (
	rngLen   = 607
	rngTap   = 273
	rngMax   = 1 << 63
	rngMask  = rngMax - 1
	int32max = (1 << 31) - 1
)

var (
	// rngCooked used for seeding. See gen_cooked.go for details.
	rngCooked [rngLen]int64 = [...]int64{
		-4181792142133755926, -4576982950128230565, 1395769623340756751, 5333664234075297259,

// Socket control messages

package unix

import (
	"unsafe"
)

// CmsgLen returns the value to store in the Len field of the Cmsghdr
// structure, taking into account any necessary alignment.
func CmsgLen(datalen int) int {
	return cmsgAlignOf(SizeofCmsghdr) + datalen
}

// CmsgSpace returns the number of bytes an ancillary element with