}

// not returns the bitwise NOT of u.
func (u uint128) not() uint128 {
	return uint128{^u.hi, ^u.lo}
}

// subOne returns u - 1.
func (u uint128) subOne() uint128 {
	lo, borrow := bits.Sub64(u.lo, 1, 0)
	return uint128{u.hi - borrow, lo}
}

// addOne returns u + 1.
func (u uint128) addOne() uint128 {
	lo, carry := bits.Add64(u.lo, 1, 0)
	return uint128{u.hi + carry, lo}
}

//go:registerparams
func sum3(i1, i2, i3 uintptr) uintptr {
	return i1 + i2 + i3
}

//go:registerparams
func sum4(i1, i2, i3, i4 uintptr) uintptr {
	return i1 + i2 + i3 + i4
}

//go:registerparams
func sum5(i1, i2, i3, i4, i5 uintptr) uintptr {
	return i1 + i2 + i3 + i4 + i5
}

//go:registerparams
func sum6(i1, i2, i3, i4, i5, i6 uintptr) uintptr {
	return i1 + i2 + i3 + i4 + i5 + i6
}

//go:registerparams

	}

	var arhdr ArHdr
	l := nextar(f, f.Offset(), &arhdr)
	if l <= 0 {
		Exitf("%s missing armap", name)
	}

	var armap archiveMap
	if arhdr.name == "/" || arhdr.name == "/SYM64/" {
		armap = readArmap(name, f, arhdr)
	} else {
		Exitf("%s missing armap", name)
	}

	loaded := make(map[uint64]bool)
	any := true
	for any {
		var load []uint64
		returnAllUndefs := -1

(Add64 x y) =>
	(Int64Make
		(Add32withcarry <typ.Int32>
			(Int64Hi x)
			(Int64Hi y)
			(Select1 <types.TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y))))
		(Select0 <typ.UInt32> (Add32carry (Int64Lo x) (Int64Lo y))))

(Sub64 x y) =>
	(Int64Make
		(Sub32withcarry <typ.Int32>
			(Int64Hi x)
			(Int64Hi y)
			(Select1 <types.TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y))))
		(Select0 <typ.UInt32> (Sub32carry (Int64Lo x) (Int64Lo y))))

			return nil, fmt.Errorf("error parsing size in archive header (%q): %v", hdrBuf[:], err)
		}

		fn := hdrBuf[arNameOff : arNameOff+arNameSize]
		if fn[0] == '/' && (fn[1] == ' ' || fn[1] == '/' || string(fn[:8]) == "/SYM64/ ") {
			// Archive symbol table or extended name table,
			// which we don't care about.
		} else {
			archiveAt := readerAtFromSeeker(archive)
			ret, err := elfFromAr(io.NewSectionReader(archiveAt, off, size))

			return true
		}
		break
	}
	// match: (Sub64 (Sub64 x y) x)
	// result: (Neg64 y)
	for {
		if v_0.Op != OpSub64 {
			break
		}
		y := v_0.Args[1]
		x := v_0.Args[0]
		if x != v_1 {
			break
		}
		v.reset(OpNeg64)
		v.AddArg(y)
		return true
	}
	// match: (Sub64 x (Add64 x y))
	// result: (Neg64 y)
	for {
		x := v_0

	}

	// Perform a subtraction with borrow.
	var borrow uint64
	for i := 0; i < len(bufA); i += 8 {
		limbA, limbB := byteorder.LeUint64(bufA[i:]), byteorder.LeUint64(bufB[i:])
		_, borrow = bits.Sub64(limbA, limbB, borrow)
	}

	// If there is a borrow at the end of the operation, then a < b.
	return borrow == 1
}

func (c *nistCurve[Point]) NewPublicKey(key []byte) (*PublicKey, error) {

}
func issue44228b(a []int32, i int) bool {
	// amd64: "BTL", -"SHL"
	return a[i>>5]&(1<<(i&31)) != 0
}

func issue48467(x, y uint64) uint64 {
	// arm64: -"NEG"
	d, borrow := bits.Sub64(x, y, 0)
	return x - d&(-borrow)
}

func foldConst(x, y uint64) uint64 {
	// arm64: "ADDS\t[$]7",-"MOVD\t[$]7"
	d, b := bits.Add64(x, 7, 0)
	return b & d
}

		{"Sym32.Shndx", Field, 0},
		{"Sym32.Size", Field, 0},
		{"Sym32.Value", Field, 0},
		{"Sym32Size", Const, 0},
		{"Sym64", Type, 0},
		{"Sym64.Info", Field, 0},
		{"Sym64.Name", Field, 0},
		{"Sym64.Other", Field, 0},
		{"Sym64.Shndx", Field, 0},
		{"Sym64.Size", Field, 0},
		{"Sym64.Value", Field, 0},
		{"Sym64Size", Const, 0},
		{"SymBind", Type, 0},
		{"SymType", Type, 0},
		{"SymVis", Type, 0},

pkg math/bits, func Mul64(uint64, uint64) (uint64, uint64)
pkg math/bits, func Sub(uint, uint, uint) (uint, uint)
pkg math/bits, func Sub32(uint32, uint32, uint32) (uint32, uint32)
pkg math/bits, func Sub64(uint64, uint64, uint64) (uint64, uint64)
pkg net/http, const StatusTooEarly = 425
pkg net/http, const StatusTooEarly ideal-int
pkg net/http, method (*Client) CloseIdleConnections()
pkg os, const ModeType = 2401763328