type math/big.Word

153 uses

	math/big (current package)
		arith.go#L16: type Word uint
		arith.go#L44: func mulWW(x, y Word) (z1, z0 Word) {
		arith.go#L46: 	return Word(hi), Word(lo)
		arith.go#L50: func mulAddWWW_g(x, y, c Word) (z1, z0 Word) {
		arith.go#L54: 	return Word(hi + cc), Word(lo)
		arith.go#L59: func nlz(x Word) uint {
		arith.go#L64: func addVV_g(z, x, y []Word) (c Word) {
		arith.go#L68: 		z[i] = Word(zi)
		arith.go#L69: 		c = Word(cc)
		arith.go#L75: func subVV_g(z, x, y []Word) (c Word) {
		arith.go#L79: 		z[i] = Word(zi)
		arith.go#L80: 		c = Word(cc)
		arith.go#L86: func addVW_g(z, x []Word, y Word) (c Word) {
		arith.go#L91: 		z[i] = Word(zi)
		arith.go#L92: 		c = Word(cc)
		arith.go#L104: func addVWlarge(z, x []Word, y Word) (c Word) {
		arith.go#L113: 		z[i] = Word(zi)
		arith.go#L114: 		c = Word(cc)
		arith.go#L119: func subVW_g(z, x []Word, y Word) (c Word) {
		arith.go#L124: 		z[i] = Word(zi)
		arith.go#L125: 		c = Word(cc)
		arith.go#L131: func subVWlarge(z, x []Word, y Word) (c Word) {
		arith.go#L140: 		z[i] = Word(zi)
		arith.go#L141: 		c = Word(cc)
		arith.go#L146: func shlVU_g(z, x []Word, s uint) (c Word) {
		arith.go#L165: func shrVU_g(z, x []Word, s uint) (c Word) {
		arith.go#L188: func mulAddVWW_g(z, x []Word, y, r Word) (c Word) {
		arith.go#L197: func addMulVVW_g(z, x []Word, y Word) (c Word) {
		arith.go#L202: 		c, z[i] = Word(cc), Word(lo)
		arith.go#L211: func divWW(x1, x0, y, m Word) (q, r Word) {
		arith.go#L267: 	return Word(qq), Word(r0 >> s)
		arith.go#L271: func reciprocalWord(d1 Word) Word {
		arith.go#L276: 	return Word(rec)
		arith_decl.go#L13: func addVV(z, x, y []Word) (c Word)
		arith_decl.go#L16: func subVV(z, x, y []Word) (c Word)
		arith_decl.go#L19: func addVW(z, x []Word, y Word) (c Word)
		arith_decl.go#L22: func subVW(z, x []Word, y Word) (c Word)
		arith_decl.go#L25: func shlVU(z, x []Word, s uint) (c Word)
		arith_decl.go#L28: func shrVU(z, x []Word, s uint) (c Word)
		arith_decl.go#L31: func mulAddVWW(z, x []Word, y, r Word) (c Word)
		arith_decl.go#L34: func addMulVVW(z, x []Word, y Word) (c Word)
		decimal.go#L109: 	var n Word
		decimal.go#L111: 		ch := Word(x.mant[r])
		decimal.go#L128: 	mask := Word(1)<<s - 1
		decimal.go#L130: 		ch := Word(x.mant[r])
		float.go#L451: 	lsb := Word(1) << ntz
		float.go#L1404: 		var xm, ym Word
		int.go#L85: 	var abs []Word
		int.go#L88: 		abs = []Word{Word(u), Word(u >> 32)}
		int.go#L90: 		abs = []Word{Word(u)}
		int.go#L109: func (x *Int) Bits() []Word {
		int.go#L121: func (z *Int) SetBits(abs []Word) *Int {
		int.go#L662: func lehmerSimulate(A, B *Int) (u0, u1, v0, v1 Word, even bool) {
		int.go#L664: 	var a1, a2, u2, v2 Word
		int.go#L715: func lehmerUpdate(A, B, q, r, s, t *Int, u0, u1, v0, v1 Word, even bool) {
		int.go#L824: 				var ua, ub, va, vb Word
		nat.go#L34: type nat []Word
		nat.go#L75: func (z nat) setWord(x Word) nat {
		nat.go#L86: 	if w := Word(x); uint64(w) == x {
		nat.go#L91: 	z[1] = Word(x >> 32)
		nat.go#L92: 	z[0] = Word(x)
		nat.go#L183: func (z nat) mulAddWW(x nat, y, r Word) nat {
		nat.go#L216: func (z nat) montgomery(x, y, m nat, k Word, n int) nat {
		nat.go#L226: 	var c Word
		nat.go#L764: 	m := Word(1) << (i % _W)
		nat.go#L920: 	mask := Word((1 << bitLengthOfMSW) - 1)
		nat.go#L926: 				z[i] = Word(rand.Uint32())
		nat.go#L930: 				z[i] = Word(rand.Uint32()) | Word(rand.Uint32())<<32
		nat.go#L1155: 	mmask := ^Word(0)
		nat.go#L1335: func bigEndianWord(buf []byte) Word {
		nat.go#L1337: 		return Word(binary.BigEndian.Uint64(buf))
		nat.go#L1339: 	return Word(binary.BigEndian.Uint32(buf))
		nat.go#L1353: 		var d Word
		nat.go#L1355: 			d |= Word(buf[i-1]) << s
		natconv.go#L31: func maxPow(b Word) (p Word, n int) {
		natconv.go#L43: func pow(x Word, n int) (p Word) {
		natconv.go#L165: 	b1 := Word(b)
		natconv.go#L167: 	di := Word(0)       // 0 <= di < b1**i < bn
		natconv.go#L185: 			var d1 Word
		natconv.go#L188: 				d1 = Word(ch - '0')
		natconv.go#L190: 				d1 = Word(ch - 'a' + 10)
		natconv.go#L193: 					d1 = Word(ch - 'A' + 10)
		natconv.go#L195: 					d1 = Word(ch - 'A' + maxBaseSmall)
		natconv.go#L282: 	if b := Word(base); b == b&-b {
		natconv.go#L285: 		mask := Word(1<<shift - 1)
		natconv.go#L368: func (q nat) convertWords(s []byte, b Word, ndigits int, bb Word, table []divisor) {
		natconv.go#L400: 	var r Word
		natconv.go#L454: func (z nat) expWW(x, y Word) nat {
		natconv.go#L459: func divisors(m int, b Word, ndigits int, bb Word) []divisor {
		natconv.go#L487: 					table[0].bbb = nat(nil).expWW(bb, Word(leafSize))
		natdiv.go#L532: 		var r2 Word
		natdiv.go#L545: func (z nat) divW(x nat, y Word) (q nat, r Word) {
		natdiv.go#L565: func (x nat) modW(d Word) (r Word) {
		natdiv.go#L574: func divWVW(z []Word, xn Word, x []Word, y Word) (r Word) {
		natdiv.go#L578: 		z[0] = Word(qq)
		natdiv.go#L579: 		return Word(rr)
		natdiv.go#L649: 		qhat := Word(_M)
		natdiv.go#L650: 		var ujn Word
		natdiv.go#L659: 			var rhat Word
		natdiv.go#L716: func greaterThan(x1, x2, y1, y2 Word) bool {
		prime.go#L168: 	p := Word(3)
		ratconv.go#L181: 		pow5 := z.b.abs.expNN(natFive, nat(nil).setWord(Word(n)), nil, false) // use underlying array of z.b.abs

	crypto/internal/boring/bbig
		big.go#L31: 	x := unsafe.Slice((*big.Word)(&b[0]), len(b))