func xorIn(d *state, buf []byte) {
	if cpu.IsBigEndian {
		for i := 0; len(buf) >= 8; i++ {
			a := binary.LittleEndian.Uint64(buf)
			d.a[i] ^= a
			buf = buf[8:]
		}
	} else {
		ab := (*[25 * 64 / 8]byte)(unsafe.Pointer(&d.a))
		subtle.XORBytes(ab[:], ab[:], buf)
	}
}

// copyOut copies uint64s to a byte buffer.
func copyOut(d *state, b []byte) {
	if cpu.IsBigEndian {
		for i := 0; len(b) >= 8; i++ {

	for i := int64(0); i < n; i++ {
		if r[i].shift != shift0+i*size*8 {
			isLittleEndian = false
			break
		}
	}
	isBigEndian := true
	for i := int64(0); i < n; i++ {
		if r[i].shift != shift0-i*size*8 {
			isBigEndian = false
			break
		}
	}
	if !isLittleEndian && !isBigEndian {
		return false
	}

	// Find a place to put the new load.
	// This is tricky, because it has to be at a point where

			if target.IsDarwin() && xadd != 0 {
				nExtReloc = 4 // need another two relocations for non-zero addend
			}

			if target.IsWindows() {
				var o0, o1 uint32
				if target.IsBigEndian() {
					o0 = uint32(val >> 32)
					o1 = uint32(val)
				} else {
					o0 = uint32(val)
					o1 = uint32(val >> 32)
				}

				// The first instruction (ADRP) has a 21-bit immediate field,

func unpackInstPair(target *ld.Target, r int64) (uint32, uint32) {
	if target.IsBigEndian() {
		return uint32(r >> 32), uint32(r)
	}
	return uint32(r), uint32(r >> 32)
}

// Pack a pair of 32 bit instruction words o1, o2 into 64 bit relocation
// in endian order.
func packInstPair(target *ld.Target, o1, o2 uint32) int64 {
	if target.IsBigEndian() {
		return (int64(o1) << 32) | int64(o2)
	}