s0 = uint32(sbox0[t0>>24])<<24 | uint32(sbox0[t1>>16&0xff])<<16 | uint32(sbox0[t2>>8&0xff])<<8 | uint32(sbox0[t3&0xff])
	s1 = uint32(sbox0[t1>>24])<<24 | uint32(sbox0[t2>>16&0xff])<<16 | uint32(sbox0[t3>>8&0xff])<<8 | uint32(sbox0[t0&0xff])
	s2 = uint32(sbox0[t2>>24])<<24 | uint32(sbox0[t3>>16&0xff])<<16 | uint32(sbox0[t0>>8&0xff])<<8 | uint32(sbox0[t1&0xff])

// byteOrder is a subset of encoding/binary.ByteOrder.
type byteOrder interface {
	Uint32([]byte) uint32
	Uint64([]byte) uint64
}

type littleEndian struct{}
type bigEndian struct{}

func (littleEndian) Uint32(b []byte) uint32 {
	_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
}

func (littleEndian) Uint64(b []byte) uint64 {

	allocationBase    uintptr
	allocationProtect uint32
	regionSize        uintptr
	state             uint32
	protect           uint32
	type_             uint32
}

// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ns-wdm-_osversioninfow
type _OSVERSIONINFOW struct {
	osVersionInfoSize uint32
	majorVersion      uint32
	minorVersion      uint32
	buildNumber       uint32
	platformId        uint32

	Cur uint64
	Max uint64
}

type _Gid_t uint32

type Stat_t struct {
	Dev     uint64
	Mode    uint32
	_       [4]byte
	Ino     uint64
	Nlink   uint32
	Uid     uint32
	Gid     uint32
	_       [4]byte
	Rdev    uint64
	Atim    Timespec
	Mtim    Timespec
	Ctim    Timespec
	Btim    Timespec
	Size    int64
	Blocks  int64
	Blksize uint32
	Flags   uint32
	Gen     uint32
	Spare   [2]uint32

//go:build unix || (js && wasm) || wasip1 || windows

package signal

import (
	"os"
	"syscall"
)

// Defined by the runtime package.
func signal_disable(uint32)
func signal_enable(uint32)
func signal_ignore(uint32)
func signal_ignored(uint32) bool
func signal_recv() uint32

func loop() {
	for {
		process(syscall.Signal(signal_recv()))
	}
}

func init() {
	watchSignalLoop = loop
}

const (

	r0, _, _ := Syscall12(procRegQueryInfoKeyW.Addr(), 12, uintptr(key), uintptr(unsafe.Pointer(class)), uintptr(unsafe.Pointer(classLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(subkeysLen)), uintptr(unsafe.Pointer(maxSubkeyLen)), uintptr(unsafe.Pointer(maxClassLen)), uintptr(unsafe.Pointer(valuesLen)), uintptr(unsafe.Poi...

	Rcv_mss              uint32
	Unacked              uint32
	Sacked               uint32
	Lost                 uint32
	Retrans              uint32
	Fackets              uint32
	Last_data_sent       uint32
	Last_ack_sent        uint32
	Last_data_recv       uint32
	Last_ack_recv        uint32
	Pmtu                 uint32
	Rcv_ssthresh         uint32
	Rtt                  uint32
	Rttvar               uint32

const c64s = 0x00ffff00004fff00

//go:noinline
func add32a(x uint32) uint32 {
	return x + c32a
}

//go:noinline
func add32s(x uint32) uint32 {
	return x + c32s
}

//go:noinline
func sub32a(x uint32) uint32 {
	return x - c32a
}

//go:noinline
func sub32s(x uint32) uint32 {
	return x - c32s
}

//go:noinline
func or32(x uint32) uint32 {
	return x | c32a
}

//go:noinline

	sys_DC
	sys_IC
	sys_TLBI
	sys_SYS
)

func sys_op_4(op1, crn, crm, op2 uint32) sys {
	sysInst := sysInstFields{uint8(op1), uint8(crn), uint8(crm), uint8(op2)}
	return sysInst.getType()
}

func is_zero(x uint32) bool {
	return x == 0
}

func is_ones_n16(x uint32) bool {
	return x == 0xffff
}

func bit_count(x uint32) uint8 {
	var count uint8
	for count = 0; x > 0; x >>= 1 {
		if (x & 1) == 1 {

		b ^= t
	}
	a, b = mix32(a, b)
	a, b = mix32(a, b)
	return uintptr(a ^ b)
}

func mix32(a, b uint32) (uint32, uint32) {
	c := uint64(a^uint32(hashkey[1])) * uint64(b^uint32(hashkey[2]))
	return uint32(c), uint32(c >> 32)