[chore] remove vendor

1 files changed, 0 insertions, 1606 deletions

diff --git a/vendor/modernc.org/mathutil/mathutil.go b/vendor/modernc.org/mathutil/mathutil.go
deleted file mode 100644
index a73c8a6e1..000000000
--- a/vendor/modernc.org/mathutil/mathutil.go
+++ /dev/null
@@ -1,1606 +0,0 @@
-// Copyright (c) 2014 The mathutil Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package mathutil provides utilities supplementing the standard 'math' and
-// 'math/rand' packages.
-//
-// # Release history and compatibility issues
-//
-// 2020-12-20 v1.2.1 fixes MulOverflowInt64.
-//
-// 2020-12-19 Added {Add,Sub,Mul}OverflowInt{8,16,32,64}
-//
-// 2018-10-21 Added BinaryLog
-//
-// 2018-04-25: New functions for determining Max/Min of nullable values. Ex:
-//
-//	func MaxPtr(a, b *int) *int {
-//	func MinPtr(a, b *int) *int {
-//	func MaxBytePtr(a, b *byte) *byte {
-//	func MinBytePtr(a, b *byte) *byte {
-//	...
-//
-// 2017-10-14: New variadic functions for Max/Min. Ex:
-//
-//	func MaxVal(val int, vals ...int) int {
-//	func MinVal(val int, vals ...int) int {
-//	func MaxByteVal(val byte, vals ...byte) byte {
-//	func MinByteVal(val byte, vals ...byte) byte {
-//	...
-//
-// 2016-10-10: New functions QuadPolyDiscriminant and QuadPolyFactors.
-//
-// 2013-12-13: The following functions have been REMOVED
-//
-//	func Uint64ToBigInt(n uint64) *big.Int
-//	func Uint64FromBigInt(n *big.Int) (uint64, bool)
-//
-// 2013-05-13: The following functions are now DEPRECATED
-//
-//	func Uint64ToBigInt(n uint64) *big.Int
-//	func Uint64FromBigInt(n *big.Int) (uint64, bool)
-//
-// These functions will be REMOVED with Go release 1.1+1.
-//
-// 2013-01-21: The following functions have been REMOVED
-//
-//	func MaxInt() int
-//	func MinInt() int
-//	func MaxUint() uint
-//	func UintPtrBits() int
-//
-// They are now replaced by untyped constants
-//
-//	MaxInt
-//	MinInt
-//	MaxUint
-//	UintPtrBits
-//
-// Additionally one more untyped constant was added
-//
-//	IntBits
-//
-// This change breaks any existing code depending on the above removed
-// functions.  They should have not been published in the first place, that was
-// unfortunate. Instead, defining such architecture and/or implementation
-// specific integer limits and bit widths as untyped constants improves
-// performance and allows for static dead code elimination if it depends on
-// these values. Thanks to minux for pointing it out in the mail list
-// (https://groups.google.com/d/msg/golang-nuts/tlPpLW6aJw8/NT3mpToH-a4J).
-//
-// 2012-12-12: The following functions will be DEPRECATED with Go release
-// 1.0.3+1 and REMOVED with Go release 1.0.3+2, b/c of
-// http://code.google.com/p/go/source/detail?r=954a79ee3ea8
-//
-//	func Uint64ToBigInt(n uint64) *big.Int
-//	func Uint64FromBigInt(n *big.Int) (uint64, bool)
-package mathutil // import "modernc.org/mathutil"
-
-import (
-	"math"
-	"math/big"
-)
-
-// Architecture and/or implementation specific integer limits and bit widths.
-const (
-	MaxInt      = 1<<(IntBits-1) - 1
-	MinInt      = -MaxInt - 1
-	MaxUint     = 1<<IntBits - 1
-	IntBits     = 1 << (^uint(0)>>32&1 + ^uint(0)>>16&1 + ^uint(0)>>8&1 + 3)
-	UintPtrBits = 1 << (^uintptr(0)>>32&1 + ^uintptr(0)>>16&1 + ^uintptr(0)>>8&1 + 3)
-)
-
-var (
-	_1 = big.NewInt(1)
-	_2 = big.NewInt(2)
-)
-
-// GCDByte returns the greatest common divisor of a and b. Based on:
-// http://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
-func GCDByte(a, b byte) byte {
-	for b != 0 {
-		a, b = b, a%b
-	}
-	return a
-}
-
-// GCDUint16 returns the greatest common divisor of a and b.
-func GCDUint16(a, b uint16) uint16 {
-	for b != 0 {
-		a, b = b, a%b
-	}
-	return a
-}
-
-// GCDUint32 returns the greatest common divisor of a and b.
-func GCDUint32(a, b uint32) uint32 {
-	for b != 0 {
-		a, b = b, a%b
-	}
-	return a
-}
-
-// GCDUint64 returns the greatest common divisor of a and b.
-func GCDUint64(a, b uint64) uint64 {
-	for b != 0 {
-		a, b = b, a%b
-	}
-	return a
-}
-
-// ISqrt returns floor(sqrt(n)). Typical run time is few hundreds of ns.
-func ISqrt(n uint32) (x uint32) {
-	if n == 0 {
-		return
-	}
-
-	if n >= math.MaxUint16*math.MaxUint16 {
-		return math.MaxUint16
-	}
-
-	var px, nx uint32
-	for x = n; ; px, x = x, nx {
-		nx = (x + n/x) / 2
-		if nx == x || nx == px {
-			break
-		}
-	}
-	return
-}
-
-// SqrtUint64 returns floor(sqrt(n)). Typical run time is about 0.5 µs.
-func SqrtUint64(n uint64) (x uint64) {
-	if n == 0 {
-		return
-	}
-
-	if n >= math.MaxUint32*math.MaxUint32 {
-		return math.MaxUint32
-	}
-
-	var px, nx uint64
-	for x = n; ; px, x = x, nx {
-		nx = (x + n/x) / 2
-		if nx == x || nx == px {
-			break
-		}
-	}
-	return
-}
-
-// SqrtBig returns floor(sqrt(n)). It panics on n < 0.
-func SqrtBig(n *big.Int) (x *big.Int) {
-	switch n.Sign() {
-	case -1:
-		panic(-1)
-	case 0:
-		return big.NewInt(0)
-	}
-
-	var px, nx big.Int
-	x = big.NewInt(0)
-	x.SetBit(x, n.BitLen()/2+1, 1)
-	for {
-		nx.Rsh(nx.Add(x, nx.Div(n, x)), 1)
-		if nx.Cmp(x) == 0 || nx.Cmp(&px) == 0 {
-			break
-		}
-		px.Set(x)
-		x.Set(&nx)
-	}
-	return
-}
-
-// Log2Byte returns log base 2 of n. It's the same as index of the highest
-// bit set in n.  For n == 0 -1 is returned.
-func Log2Byte(n byte) int {
-	return log2[n]
-}
-
-// Log2Uint16 returns log base 2 of n. It's the same as index of the highest
-// bit set in n.  For n == 0 -1 is returned.
-func Log2Uint16(n uint16) int {
-	if b := n >> 8; b != 0 {
-		return log2[b] + 8
-	}
-
-	return log2[n]
-}
-
-// Log2Uint32 returns log base 2 of n. It's the same as index of the highest
-// bit set in n.  For n == 0 -1 is returned.
-func Log2Uint32(n uint32) int {
-	if b := n >> 24; b != 0 {
-		return log2[b] + 24
-	}
-
-	if b := n >> 16; b != 0 {
-		return log2[b] + 16
-	}
-
-	if b := n >> 8; b != 0 {
-		return log2[b] + 8
-	}
-
-	return log2[n]
-}
-
-// Log2Uint64 returns log base 2 of n. It's the same as index of the highest
-// bit set in n.  For n == 0 -1 is returned.
-func Log2Uint64(n uint64) int {
-	if b := n >> 56; b != 0 {
-		return log2[b] + 56
-	}
-
-	if b := n >> 48; b != 0 {
-		return log2[b] + 48
-	}
-
-	if b := n >> 40; b != 0 {
-		return log2[b] + 40
-	}
-
-	if b := n >> 32; b != 0 {
-		return log2[b] + 32
-	}
-
-	if b := n >> 24; b != 0 {
-		return log2[b] + 24
-	}
-
-	if b := n >> 16; b != 0 {
-		return log2[b] + 16
-	}
-
-	if b := n >> 8; b != 0 {
-		return log2[b] + 8
-	}
-
-	return log2[n]
-}
-
-// ModPowByte computes (b^e)%m. It panics for m == 0 || b == e == 0.
-//
-// See also: http://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method
-func ModPowByte(b, e, m byte) byte {
-	if b == 0 && e == 0 {
-		panic(0)
-	}
-
-	if m == 1 {
-		return 0
-	}
-
-	r := uint16(1)
-	for b, m := uint16(b), uint16(m); e > 0; b, e = b*b%m, e>>1 {
-		if e&1 == 1 {
-			r = r * b % m
-		}
-	}
-	return byte(r)
-}
-
-// ModPowUint16 computes (b^e)%m. It panics for m == 0 || b == e == 0.
-func ModPowUint16(b, e, m uint16) uint16 {
-	if b == 0 && e == 0 {
-		panic(0)
-	}
-
-	if m == 1 {
-		return 0
-	}
-
-	r := uint32(1)
-	for b, m := uint32(b), uint32(m); e > 0; b, e = b*b%m, e>>1 {
-		if e&1 == 1 {
-			r = r * b % m
-		}
-	}
-	return uint16(r)
-}
-
-// ModPowUint32 computes (b^e)%m. It panics for m == 0 || b == e == 0.
-func ModPowUint32(b, e, m uint32) uint32 {
-	if b == 0 && e == 0 {
-		panic(0)
-	}
-
-	if m == 1 {
-		return 0
-	}
-
-	r := uint64(1)
-	for b, m := uint64(b), uint64(m); e > 0; b, e = b*b%m, e>>1 {
-		if e&1 == 1 {
-			r = r * b % m
-		}
-	}
-	return uint32(r)
-}
-
-// ModPowUint64 computes (b^e)%m. It panics for m == 0 || b == e == 0.
-func ModPowUint64(b, e, m uint64) (r uint64) {
-	if b == 0 && e == 0 {
-		panic(0)
-	}
-
-	if m == 1 {
-		return 0
-	}
-
-	return modPowBigInt(big.NewInt(0).SetUint64(b), big.NewInt(0).SetUint64(e), big.NewInt(0).SetUint64(m)).Uint64()
-}
-
-func modPowBigInt(b, e, m *big.Int) (r *big.Int) {
-	r = big.NewInt(1)
-	for i, n := 0, e.BitLen(); i < n; i++ {
-		if e.Bit(i) != 0 {
-			r.Mod(r.Mul(r, b), m)
-		}
-		b.Mod(b.Mul(b, b), m)
-	}
-	return
-}
-
-// ModPowBigInt computes (b^e)%m. Returns nil for e < 0. It panics for m == 0 || b == e == 0.
-func ModPowBigInt(b, e, m *big.Int) (r *big.Int) {
-	if b.Sign() == 0 && e.Sign() == 0 {
-		panic(0)
-	}
-
-	if m.Cmp(_1) == 0 {
-		return big.NewInt(0)
-	}
-
-	if e.Sign() < 0 {
-		return
-	}
-
-	return modPowBigInt(big.NewInt(0).Set(b), big.NewInt(0).Set(e), m)
-}
-
-var uint64ToBigIntDelta big.Int
-
-func init() {
-	uint64ToBigIntDelta.SetBit(&uint64ToBigIntDelta, 63, 1)
-}
-
-var uintptrBits int
-
-func init() {
-	x := uint64(math.MaxUint64)
-	uintptrBits = BitLenUintptr(uintptr(x))
-}
-
-// UintptrBits returns the bit width of an uintptr at the executing machine.
-func UintptrBits() int {
-	return uintptrBits
-}
-
-// AddUint128_64 returns the uint128 sum of uint64 a and b.
-func AddUint128_64(a, b uint64) (hi uint64, lo uint64) {
-	lo = a + b
-	if lo < a {
-		hi = 1
-	}
-	return hi, lo
-}
-
-// MulUint128_64 returns the uint128 bit product of uint64 a and b.
-func MulUint128_64(a, b uint64) (hi, lo uint64) {
-	/*
-		2^(2 W) ahi bhi + 2^W alo bhi + 2^W ahi blo + alo blo
-
-		FEDCBA98 76543210 FEDCBA98 76543210
-		                  ---- alo*blo ----
-		         ---- alo*bhi ----
-		         ---- ahi*blo ----
-		---- ahi*bhi ----
-	*/
-	const w = 32
-	const m = 1<<w - 1
-	ahi, bhi, alo, blo := a>>w, b>>w, a&m, b&m
-	lo = alo * blo
-	mid1 := alo * bhi
-	mid2 := ahi * blo
-	c1, lo := AddUint128_64(lo, mid1<<w)
-	c2, lo := AddUint128_64(lo, mid2<<w)
-	_, hi = AddUint128_64(ahi*bhi, mid1>>w+mid2>>w+c1+c2)
-	return
-}
-
-// PowerizeBigInt returns (e, p) such that e is the smallest number for which p
-// == b^e is greater or equal n. For n < 0 or b < 2 (0, nil) is returned.
-//
-// NOTE: Run time for large values of n (above about 2^1e6 ~= 1e300000) can be
-// significant and/or unacceptabe.  For any smaller values of n the function
-// typically performs in sub second time.  For "small" values of n (cca bellow
-// 2^1e3 ~= 1e300) the same can be easily below 10 µs.
-//
-// A special (and trivial) case of b == 2 is handled separately and performs
-// much faster.
-func PowerizeBigInt(b, n *big.Int) (e uint32, p *big.Int) {
-	switch {
-	case b.Cmp(_2) < 0 || n.Sign() < 0:
-		return
-	case n.Sign() == 0 || n.Cmp(_1) == 0:
-		return 0, big.NewInt(1)
-	case b.Cmp(_2) == 0:
-		p = big.NewInt(0)
-		e = uint32(n.BitLen() - 1)
-		p.SetBit(p, int(e), 1)
-		if p.Cmp(n) < 0 {
-			p.Mul(p, _2)
-			e++
-		}
-		return
-	}
-
-	bw := b.BitLen()
-	nw := n.BitLen()
-	p = big.NewInt(1)
-	var bb, r big.Int
-	for {
-		switch p.Cmp(n) {
-		case -1:
-			x := uint32((nw - p.BitLen()) / bw)
-			if x == 0 {
-				x = 1
-			}
-			e += x
-			switch x {
-			case 1:
-				p.Mul(p, b)
-			default:
-				r.Set(_1)
-				bb.Set(b)
-				e := x
-				for {
-					if e&1 != 0 {
-						r.Mul(&r, &bb)
-					}
-					if e >>= 1; e == 0 {
-						break
-					}
-
-					bb.Mul(&bb, &bb)
-				}
-				p.Mul(p, &r)
-			}
-		case 0, 1:
-			return
-		}
-	}
-}
-
-// PowerizeUint32BigInt returns (e, p) such that e is the smallest number for
-// which p == b^e is greater or equal n. For n < 0 or b < 2 (0, nil) is
-// returned.
-//
-// More info: see PowerizeBigInt.
-func PowerizeUint32BigInt(b uint32, n *big.Int) (e uint32, p *big.Int) {
-	switch {
-	case b < 2 || n.Sign() < 0:
-		return
-	case n.Sign() == 0 || n.Cmp(_1) == 0:
-		return 0, big.NewInt(1)
-	case b == 2:
-		p = big.NewInt(0)
-		e = uint32(n.BitLen() - 1)
-		p.SetBit(p, int(e), 1)
-		if p.Cmp(n) < 0 {
-			p.Mul(p, _2)
-			e++
-		}
-		return
-	}
-
-	var bb big.Int
-	bb.SetInt64(int64(b))
-	return PowerizeBigInt(&bb, n)
-}
-
-/*
-ProbablyPrimeUint32 returns true if n is prime or n is a pseudoprime to base a.
-It implements the Miller-Rabin primality test for one specific value of 'a' and
-k == 1.
-
-Wrt pseudocode shown at
-http://en.wikipedia.org/wiki/Miller-Rabin_primality_test#Algorithm_and_running_time
-
-	Input: n > 3, an odd integer to be tested for primality;
-	Input: k, a parameter that determines the accuracy of the test
-	Output: composite if n is composite, otherwise probably prime
-	write n − 1 as 2^s·d with d odd by factoring powers of 2 from n − 1
-	LOOP: repeat k times:
-	   pick a random integer a in the range [2, n − 2]
-	   x ← a^d mod n
-	   if x = 1 or x = n − 1 then do next LOOP
-	   for r = 1 .. s − 1
-	      x ← x^2 mod n
-	      if x = 1 then return composite
-	      if x = n − 1 then do next LOOP
-	   return composite
-	return probably prime
-
-... this function behaves like passing 1 for 'k' and additionally a
-fixed/non-random 'a'.  Otherwise it's the same algorithm.
-
-See also: http://mathworld.wolfram.com/Rabin-MillerStrongPseudoprimeTest.html
-*/
-func ProbablyPrimeUint32(n, a uint32) bool {
-	d, s := n-1, 0
-	for ; d&1 == 0; d, s = d>>1, s+1 {
-	}
-	x := uint64(ModPowUint32(a, d, n))
-	if x == 1 || uint32(x) == n-1 {
-		return true
-	}
-
-	for ; s > 1; s-- {
-		if x = x * x % uint64(n); x == 1 {
-			return false
-		}
-
-		if uint32(x) == n-1 {
-			return true
-		}
-	}
-	return false
-}
-
-// ProbablyPrimeUint64_32 returns true if n is prime or n is a pseudoprime to
-// base a. It implements the Miller-Rabin primality test for one specific value
-// of 'a' and k == 1.  See also ProbablyPrimeUint32.
-func ProbablyPrimeUint64_32(n uint64, a uint32) bool {
-	d, s := n-1, 0
-	for ; d&1 == 0; d, s = d>>1, s+1 {
-	}
-	x := ModPowUint64(uint64(a), d, n)
-	if x == 1 || x == n-1 {
-		return true
-	}
-
-	bx, bn := big.NewInt(0).SetUint64(x), big.NewInt(0).SetUint64(n)
-	for ; s > 1; s-- {
-		if x = bx.Mod(bx.Mul(bx, bx), bn).Uint64(); x == 1 {
-			return false
-		}
-
-		if x == n-1 {
-			return true
-		}
-	}
-	return false
-}
-
-// ProbablyPrimeBigInt_32 returns true if n is prime or n is a pseudoprime to
-// base a. It implements the Miller-Rabin primality test for one specific value
-// of 'a' and k == 1.  See also ProbablyPrimeUint32.
-func ProbablyPrimeBigInt_32(n *big.Int, a uint32) bool {
-	var d big.Int
-	d.Set(n)
-	d.Sub(&d, _1) // d <- n-1
-	s := 0
-	for ; d.Bit(s) == 0; s++ {
-	}
-	nMinus1 := big.NewInt(0).Set(&d)
-	d.Rsh(&d, uint(s))
-
-	x := ModPowBigInt(big.NewInt(int64(a)), &d, n)
-	if x.Cmp(_1) == 0 || x.Cmp(nMinus1) == 0 {
-		return true
-	}
-
-	for ; s > 1; s-- {
-		if x = x.Mod(x.Mul(x, x), n); x.Cmp(_1) == 0 {
-			return false
-		}
-
-		if x.Cmp(nMinus1) == 0 {
-			return true
-		}
-	}
-	return false
-}
-
-// ProbablyPrimeBigInt returns true if n is prime or n is a pseudoprime to base
-// a. It implements the Miller-Rabin primality test for one specific value of
-// 'a' and k == 1.  See also ProbablyPrimeUint32.
-func ProbablyPrimeBigInt(n, a *big.Int) bool {
-	var d big.Int
-	d.Set(n)
-	d.Sub(&d, _1) // d <- n-1
-	s := 0
-	for ; d.Bit(s) == 0; s++ {
-	}
-	nMinus1 := big.NewInt(0).Set(&d)
-	d.Rsh(&d, uint(s))
-
-	x := ModPowBigInt(a, &d, n)
-	if x.Cmp(_1) == 0 || x.Cmp(nMinus1) == 0 {
-		return true
-	}
-
-	for ; s > 1; s-- {
-		if x = x.Mod(x.Mul(x, x), n); x.Cmp(_1) == 0 {
-			return false
-		}
-
-		if x.Cmp(nMinus1) == 0 {
-			return true
-		}
-	}
-	return false
-}
-
-// Max returns the larger of a and b.
-func Max(a, b int) int {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// Min returns the smaller of a and b.
-func Min(a, b int) int {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxPtr returns a pointer to the larger of a and b, or nil.
-func MaxPtr(a, b *int) *int {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinPtr returns a pointer to the smaller of a and b, or nil.
-func MinPtr(a, b *int) *int {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxVal returns the largest argument passed.
-func MaxVal(val int, vals ...int) int {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinVal returns the smallest argument passed.
-func MinVal(val int, vals ...int) int {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// Clamp returns a value restricted between lo and hi.
-func Clamp(v, lo, hi int) int {
-	return Min(Max(v, lo), hi)
-}
-
-// UMax returns the larger of a and b.
-func UMax(a, b uint) uint {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// UMin returns the smaller of a and b.
-func UMin(a, b uint) uint {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// UMaxPtr returns a pointer to the larger of a and b, or nil.
-func UMaxPtr(a, b *uint) *uint {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// UMinPtr returns a pointer to the smaller of a and b, or nil.
-func UMinPtr(a, b *uint) *uint {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// UMaxVal returns the largest argument passed.
-func UMaxVal(val uint, vals ...uint) uint {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// UMinVal returns the smallest argument passed.
-func UMinVal(val uint, vals ...uint) uint {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// UClamp returns a value restricted between lo and hi.
-func UClamp(v, lo, hi uint) uint {
-	return UMin(UMax(v, lo), hi)
-}
-
-// MaxByte returns the larger of a and b.
-func MaxByte(a, b byte) byte {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinByte returns the smaller of a and b.
-func MinByte(a, b byte) byte {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxBytePtr returns a pointer to the larger of a and b, or nil.
-func MaxBytePtr(a, b *byte) *byte {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinBytePtr returns a pointer to the smaller of a and b, or nil.
-func MinBytePtr(a, b *byte) *byte {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxByteVal returns the largest argument passed.
-func MaxByteVal(val byte, vals ...byte) byte {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinByteVal returns the smallest argument passed.
-func MinByteVal(val byte, vals ...byte) byte {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampByte returns a value restricted between lo and hi.
-func ClampByte(v, lo, hi byte) byte {
-	return MinByte(MaxByte(v, lo), hi)
-}
-
-// MaxInt8 returns the larger of a and b.
-func MaxInt8(a, b int8) int8 {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt8 returns the smaller of a and b.
-func MinInt8(a, b int8) int8 {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt8Ptr returns a pointer to the larger of a and b, or nil.
-func MaxInt8Ptr(a, b *int8) *int8 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt8Ptr returns a pointer to the smaller of a and b, or nil.
-func MinInt8Ptr(a, b *int8) *int8 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt8Val returns the largest argument passed.
-func MaxInt8Val(val int8, vals ...int8) int8 {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinInt8Val returns the smallest argument passed.
-func MinInt8Val(val int8, vals ...int8) int8 {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampInt8 returns a value restricted between lo and hi.
-func ClampInt8(v, lo, hi int8) int8 {
-	return MinInt8(MaxInt8(v, lo), hi)
-}
-
-// MaxUint16 returns the larger of a and b.
-func MaxUint16(a, b uint16) uint16 {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinUint16 returns the smaller of a and b.
-func MinUint16(a, b uint16) uint16 {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxUint16Ptr returns a pointer to the larger of a and b, or nil.
-func MaxUint16Ptr(a, b *uint16) *uint16 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinUint16Ptr returns a pointer to the smaller of a and b, or nil.
-func MinUint16Ptr(a, b *uint16) *uint16 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxUint16Val returns the largest argument passed.
-func MaxUint16Val(val uint16, vals ...uint16) uint16 {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinUint16Val returns the smallest argument passed.
-func MinUint16Val(val uint16, vals ...uint16) uint16 {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampUint16 returns a value restricted between lo and hi.
-func ClampUint16(v, lo, hi uint16) uint16 {
-	return MinUint16(MaxUint16(v, lo), hi)
-}
-
-// MaxInt16 returns the larger of a and b.
-func MaxInt16(a, b int16) int16 {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt16 returns the smaller of a and b.
-func MinInt16(a, b int16) int16 {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt16Ptr returns a pointer to the larger of a and b, or nil.
-func MaxInt16Ptr(a, b *int16) *int16 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt16Ptr returns a pointer to the smaller of a and b, or nil.
-func MinInt16Ptr(a, b *int16) *int16 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt16Val returns the largest argument passed.
-func MaxInt16Val(val int16, vals ...int16) int16 {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinInt16Val returns the smallest argument passed.
-func MinInt16Val(val int16, vals ...int16) int16 {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampInt16 returns a value restricted between lo and hi.
-func ClampInt16(v, lo, hi int16) int16 {
-	return MinInt16(MaxInt16(v, lo), hi)
-}
-
-// MaxUint32 returns the larger of a and b.
-func MaxUint32(a, b uint32) uint32 {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinUint32 returns the smaller of a and b.
-func MinUint32(a, b uint32) uint32 {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxUint32Ptr returns a pointer to the larger of a and b, or nil.
-func MaxUint32Ptr(a, b *uint32) *uint32 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinUint32Ptr returns a pointer to the smaller of a and b, or nil.
-func MinUint32Ptr(a, b *uint32) *uint32 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxUint32Val returns the largest argument passed.
-func MaxUint32Val(val uint32, vals ...uint32) uint32 {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinUint32Val returns the smallest argument passed.
-func MinUint32Val(val uint32, vals ...uint32) uint32 {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampUint32 returns a value restricted between lo and hi.
-func ClampUint32(v, lo, hi uint32) uint32 {
-	return MinUint32(MaxUint32(v, lo), hi)
-}
-
-// MaxInt32 returns the larger of a and b.
-func MaxInt32(a, b int32) int32 {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt32 returns the smaller of a and b.
-func MinInt32(a, b int32) int32 {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt32Ptr returns a pointer to the larger of a and b, or nil.
-func MaxInt32Ptr(a, b *int32) *int32 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt32Ptr returns a pointer to the smaller of a and b, or nil.
-func MinInt32Ptr(a, b *int32) *int32 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt32Val returns the largest argument passed.
-func MaxInt32Val(val int32, vals ...int32) int32 {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinInt32Val returns the smallest argument passed.
-func MinInt32Val(val int32, vals ...int32) int32 {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampInt32 returns a value restricted between lo and hi.
-func ClampInt32(v, lo, hi int32) int32 {
-	return MinInt32(MaxInt32(v, lo), hi)
-}
-
-// MaxUint64 returns the larger of a and b.
-func MaxUint64(a, b uint64) uint64 {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinUint64 returns the smaller of a and b.
-func MinUint64(a, b uint64) uint64 {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxUint64Ptr returns a pointer to the larger of a and b, or nil.
-func MaxUint64Ptr(a, b *uint64) *uint64 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinUint64Ptr returns a pointer to the smaller of a and b, or nil.
-func MinUint64Ptr(a, b *uint64) *uint64 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxUint64Val returns the largest argument passed.
-func MaxUint64Val(val uint64, vals ...uint64) uint64 {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinUint64Val returns the smallest argument passed.
-func MinUint64Val(val uint64, vals ...uint64) uint64 {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampUint64 returns a value restricted between lo and hi.
-func ClampUint64(v, lo, hi uint64) uint64 {
-	return MinUint64(MaxUint64(v, lo), hi)
-}
-
-// MaxInt64 returns the larger of a and b.
-func MaxInt64(a, b int64) int64 {
-	if a > b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt64 returns the smaller of a and b.
-func MinInt64(a, b int64) int64 {
-	if a < b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt64Ptr returns a pointer to the larger of a and b, or nil.
-func MaxInt64Ptr(a, b *int64) *int64 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a > *b {
-		return a
-	}
-
-	return b
-}
-
-// MinInt64Ptr returns a pointer to the smaller of a and b, or nil.
-func MinInt64Ptr(a, b *int64) *int64 {
-	if a == nil {
-		return b
-	}
-	if b == nil {
-		return a
-	}
-	if *a < *b {
-		return a
-	}
-
-	return b
-}
-
-// MaxInt64Val returns the largest argument passed.
-func MaxInt64Val(val int64, vals ...int64) int64 {
-	res := val
-	for _, v := range vals {
-		if v > res {
-			res = v
-		}
-	}
-	return res
-}
-
-// MinInt64Val returns the smallest argument passed.
-func MinInt64Val(val int64, vals ...int64) int64 {
-	res := val
-	for _, v := range vals {
-		if v < res {
-			res = v
-		}
-	}
-	return res
-}
-
-// ClampInt64 returns a value restricted between lo and hi.
-func ClampInt64(v, lo, hi int64) int64 {
-	return MinInt64(MaxInt64(v, lo), hi)
-}
-
-// ToBase produces n in base b. For example
-//
-//	ToBase(2047, 22) -> [1, 5, 4]
-//
-//	1 * 22^0           1
-//	5 * 22^1         110
-//	4 * 22^2        1936
-//	                ----
-//	                2047
-//
-// ToBase panics for bases < 2.
-func ToBase(n *big.Int, b int) []int {
-	var nn big.Int
-	nn.Set(n)
-	if b < 2 {
-		panic("invalid base")
-	}
-
-	k := 1
-	switch nn.Sign() {
-	case -1:
-		nn.Neg(&nn)
-		k = -1
-	case 0:
-		return []int{0}
-	}
-
-	bb := big.NewInt(int64(b))
-	var r []int
-	rem := big.NewInt(0)
-	for nn.Sign() != 0 {
-		nn.QuoRem(&nn, bb, rem)
-		r = append(r, k*int(rem.Int64()))
-	}
-	return r
-}
-
-// CheckAddInt64 returns the a+b and an indicator that the result is greater
-// than math.MaxInt64.
-func CheckAddInt64(a, b int64) (sum int64, gt bool) {
-	return a + b, a > 0 && b > math.MaxInt64-a || a < 0 && b < math.MinInt64-a
-}
-
-// CheckSubInt64 returns a-b and an indicator that the result is less than than
-// math.MinInt64.
-func CheckSubInt64(a, b int64) (sum int64, lt bool) {
-	return a - b, a > 0 && a-math.MaxInt64 > b || a < 0 && a-math.MinInt64 < b
-}
-
-// AddOverflowInt8 returns a + b and an indication whether the addition
-// overflowed the int8 range.
-func AddOverflowInt8(a, b int8) (r int8, ovf bool) {
-	r = a + b
-	if a > 0 && b > 0 {
-		return r, uint8(r) > math.MaxInt8
-	}
-
-	if a < 0 && b < 0 {
-		return r, uint8(r) <= math.MaxInt8
-	}
-
-	return r, false
-}
-
-// AddOverflowInt16 returns a + b and an indication whether the addition
-// overflowed the int16 range.
-func AddOverflowInt16(a, b int16) (r int16, ovf bool) {
-	r = a + b
-	if a > 0 && b > 0 {
-		return r, uint16(r) > math.MaxInt16
-	}
-
-	if a < 0 && b < 0 {
-		return r, uint16(r) <= math.MaxInt16
-	}
-
-	return r, false
-}
-
-// AddOverflowInt32 returns a + b and an indication whether the addition
-// overflowed the int32 range.
-func AddOverflowInt32(a, b int32) (r int32, ovf bool) {
-	r = a + b
-	if a > 0 && b > 0 {
-		return r, uint32(r) > math.MaxInt32
-	}
-
-	if a < 0 && b < 0 {
-		return r, uint32(r) <= math.MaxInt32
-	}
-
-	return r, false
-}
-
-// AddOverflowInt64 returns a + b and an indication whether the addition
-// overflowed the int64 range.
-func AddOverflowInt64(a, b int64) (r int64, ovf bool) {
-	r = a + b
-	if a > 0 && b > 0 {
-		return r, uint64(r) > math.MaxInt64
-	}
-
-	if a < 0 && b < 0 {
-		return r, uint64(r) <= math.MaxInt64
-	}
-
-	return r, false
-}
-
-// SubOverflowInt8 returns a - b and an indication whether the subtraction
-// overflowed the int8 range.
-func SubOverflowInt8(a, b int8) (r int8, ovf bool) {
-	r = a - b
-	if a >= 0 && b < 0 {
-		return r, uint8(r) >= math.MaxInt8+1
-	}
-
-	if a < 0 && b > 0 {
-		return r, uint8(r) <= math.MaxInt8
-	}
-
-	return r, false
-}
-
-// SubOverflowInt16 returns a - b and an indication whether the subtraction
-// overflowed the int16 range.
-func SubOverflowInt16(a, b int16) (r int16, ovf bool) {
-	r = a - b
-	if a >= 0 && b < 0 {
-		return r, uint16(r) >= math.MaxInt16+1
-	}
-
-	if a < 0 && b > 0 {
-		return r, uint16(r) <= math.MaxInt16
-	}
-
-	return r, false
-}
-
-// SubOverflowInt32 returns a - b and an indication whether the subtraction
-// overflowed the int32 range.
-func SubOverflowInt32(a, b int32) (r int32, ovf bool) {
-	r = a - b
-	if a >= 0 && b < 0 {
-		return r, uint32(r) >= math.MaxInt32+1
-	}
-
-	if a < 0 && b > 0 {
-		return r, uint32(r) <= math.MaxInt32
-	}
-
-	return r, false
-}
-
-// SubOverflowInt64 returns a - b and an indication whether the subtraction
-// overflowed the int64 range.
-func SubOverflowInt64(a, b int64) (r int64, ovf bool) {
-	r = a - b
-	if a >= 0 && b < 0 {
-		return r, uint64(r) >= math.MaxInt64+1
-	}
-
-	if a < 0 && b > 0 {
-		return r, uint64(r) <= math.MaxInt64
-	}
-
-	return r, false
-}
-
-// MulOverflowInt8 returns a * b and an indication whether the product
-// overflowed the int8 range.
-func MulOverflowInt8(a, b int8) (r int8, ovf bool) {
-	if a == 0 || b == 0 {
-		return 0, false
-	}
-
-	z := int16(a) * int16(b)
-	return int8(z), z < math.MinInt8 || z > math.MaxInt8
-}
-
-// MulOverflowInt16 returns a * b and an indication whether the product
-// overflowed the int16 range.
-func MulOverflowInt16(a, b int16) (r int16, ovf bool) {
-	if a == 0 || b == 0 {
-		return 0, false
-	}
-
-	z := int32(a) * int32(b)
-	return int16(z), z < math.MinInt16 || z > math.MaxInt16
-}
-
-// MulOverflowInt32 returns a * b and an indication whether the product
-// overflowed the int32 range.
-func MulOverflowInt32(a, b int32) (r int32, ovf bool) {
-	if a == 0 || b == 0 {
-		return 0, false
-	}
-
-	z := int64(a) * int64(b)
-	return int32(z), z < math.MinInt32 || z > math.MaxInt32
-}
-
-// MulOverflowInt64 returns a * b and an indication whether the product
-// overflowed the int64 range.
-func MulOverflowInt64(a, b int64) (r int64, ovf bool) {
-	// https://groups.google.com/g/golang-nuts/c/h5oSN5t3Au4/m/KaNQREhZh0QJ
-	const mostPositive = 1<<63 - 1
-	const mostNegative = -(mostPositive + 1)
-	r = a * b
-	if a == 0 || b == 0 || a == 1 || b == 1 {
-		return r, false
-	}
-
-	if a == mostNegative || b == mostNegative {
-		return r, true
-	}
-
-	return r, r/b != a
-}