[chore] remove vendor

1 files changed, 0 insertions, 279 deletions

diff --git a/vendor/modernc.org/mathutil/int.go b/vendor/modernc.org/mathutil/int.go
deleted file mode 100644
index 7c3578764..000000000
--- a/vendor/modernc.org/mathutil/int.go
+++ /dev/null
@@ -1,279 +0,0 @@
-// Copyright (c) 2018 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 // import "modernc.org/mathutil"
-
-import (
-	"fmt"
-	"math"
-	"math/big"
-)
-
-var (
-	// MaxInt128 represents the maximun Int128 value as big.Int
-	MaxInt128 *big.Int
-	// MinInt128 represents the minimun Int128 value as big.Int
-	MinInt128 *big.Int
-	// MaxUint128 represents the maximun Uint128 value as big.Int
-	MaxUint128 *big.Int
-)
-
-func init() {
-	var ok bool
-	MaxInt128, ok = big.NewInt(0).SetString("0x7fffffff_ffffffff_ffffffff_ffffffff", 0)
-	if !ok {
-		panic("internal error")
-	}
-
-	MinInt128 = big.NewInt(0).Set(MaxInt128)
-	MinInt128.Add(MinInt128, _1)
-	MinInt128.Neg(MinInt128)
-
-	MaxUint128, ok = big.NewInt(0).SetString("0xffffffff_ffffffff_ffffffff_ffffffff", 0)
-	if !ok {
-		panic("internal error")
-	}
-}
-
-const (
-	maxInt128  = 1<<127 - 1
-	maxUint128 = 1<<128 - 1
-	minInt128  = -maxInt128 - 1
-)
-
-// Int128 is an 128 bit signed integer.
-type Int128 struct {
-	Lo int64 // Bits 63..0.
-	Hi int64 // Bits 127..64.
-}
-
-// Add returns the sum of x and y and a carry indication.
-func (x Int128) Add(y Int128) (r Int128, cy bool) {
-	r.Lo = x.Lo + y.Lo
-	r.Hi = x.Hi + y.Hi
-	if uint64(r.Lo) < uint64(x.Lo) {
-		r.Hi++
-	}
-	return r, (r.Cmp(x) < 0) == (y.Sign() >= 0)
-}
-
-// BigInt returns x in the form of a big.Int.
-func (x Int128) BigInt() *big.Int {
-	r := big.NewInt(x.Hi)
-	r.Lsh(r, 64)
-	lo := big.NewInt(0)
-	lo.SetUint64(uint64(x.Lo))
-	return r.Add(r, lo)
-}
-
-// Cmp compares x and y and returns:
-//
-//	-1 if x <  y
-//	 0 if x == y
-//	+1 if x >  y
-func (x Int128) Cmp(y Int128) int {
-	if x.Hi > y.Hi {
-		return 1
-	}
-
-	if x.Hi < y.Hi {
-		return -1
-	}
-
-	if uint64(x.Lo) > uint64(y.Lo) {
-		return 1
-	}
-
-	if uint64(x.Lo) < uint64(y.Lo) {
-		return -1
-	}
-
-	return 0
-}
-
-// Neg returns -x and an indication that x was not equal to MinInt128.
-func (x Int128) Neg() (r Int128, ok bool) {
-	if x == (Int128{Hi: math.MinInt64}) {
-		return x, false
-	}
-
-	x.Lo = ^x.Lo
-	x.Hi = ^x.Hi
-	r, _ = x.Add(Int128{Lo: 1})
-	return r, true
-}
-
-// SetBigInt sets x to y, returns x and an error, if any.
-func (x *Int128) SetBigInt(y *big.Int) (r Int128, err error) {
-	if y.Cmp(MaxInt128) > 0 {
-		return *x, fmt.Errorf("%T.SetInt: overflow", x)
-	}
-	if y.Cmp(MinInt128) < 0 {
-		return *x, fmt.Errorf("%T.SetInt: underflow", x)
-	}
-	neg := y.Sign() < 0
-	var z big.Int
-	z.Set(y)
-	if neg {
-		z.Neg(&z)
-	}
-	r.Lo = z.Int64()
-	z.Rsh(&z, 64)
-	r.Hi = z.Int64()
-	if neg {
-		r, _ = r.Neg()
-	}
-	*x = r
-	return r, nil
-}
-
-// SetInt64 sets x to y and returns x.
-func (x *Int128) SetInt64(y int64) (r Int128) {
-	r.Lo = y
-	if y >= 0 {
-		r.Hi = 0
-		*x = r
-		return r
-	}
-
-	r.Hi = -1
-	*x = r
-	return r
-}
-
-// SetUint64 sets x to y and returns x.
-func (x *Int128) SetUint64(y uint64) (r Int128) {
-	r = Int128{Lo: int64(y)}
-	*x = r
-	return r
-}
-
-// Sign returns:
-//
-//	-1 if x <  0
-//	 0 if x == 0
-//	+1 if x >  0
-func (x Int128) Sign() int {
-	if x.Hi < 0 {
-		return -1
-	}
-
-	if x.Hi != 0 || x.Lo != 0 {
-		return 1
-	}
-
-	return 0
-}
-
-// String implements fmt.Stringer()
-func (x Int128) String() string { return x.BigInt().String() }
-
-// NewInt128FromInt64 return a new Int128 value initialized to n.
-func NewInt128FromInt64(n int64) (r Int128) {
-	r.Lo = n
-	if n < 0 {
-		r.Hi = -1
-	}
-	return r
-}
-
-// NewInt128FromUint64 return a new Int128 value initialized to n.
-func NewInt128FromUint64(n uint64) (r Int128) { return Int128{Lo: int64(n)} }
-
-// NewInt128FromFloat32 returns a new Int128 value initialized to n. Result is
-// not specified in n does not represent a number within the range of Int128
-// values.
-func NewInt128FromFloat32(n float32) (r Int128) {
-	if n >= minInt128 && n <= maxInt128 {
-		if n >= math.MinInt64 && n <= math.MaxInt64 {
-			return NewInt128FromInt64(int64(n))
-		}
-
-		f := big.NewFloat(float64(n))
-		bi, _ := f.Int(nil)
-		r.SetBigInt(bi)
-	}
-	return r
-}
-
-// NewInt128FromFloat64 returns a new Int128 value initialized to n. Result is
-// not specified in n does not represent a number within the range of Int128
-// values.
-func NewInt128FromFloat64(n float64) (r Int128) {
-	if n >= minInt128 && n <= maxInt128 {
-		if n >= math.MinInt64 && n <= math.MaxInt64 {
-			return NewInt128FromInt64(int64(n))
-		}
-
-		f := big.NewFloat(n)
-		bi, _ := f.Int(nil)
-		r.SetBigInt(bi)
-	}
-	return r
-}
-
-// Uint128 is an 128 bit unsigned integer.
-type Uint128 struct {
-	Lo uint64 // Bits 63..0.
-	Hi uint64 // Bits 127..64.
-}
-
-// NewUint128FromInt64 return a new Uint128 value initialized to n.
-func NewUint128FromInt64(n int64) (r Uint128) {
-	r.Lo = uint64(n)
-	if n < 0 {
-		r.Hi = ^uint64(0)
-	}
-	return r
-}
-
-// NewUint128FromUint64 return a new Uint128 value initialized to n.
-func NewUint128FromUint64(n uint64) (r Uint128) { return Uint128{Lo: n} }
-
-// NewUint128FromFloat32 returns a new Uint128 value initialized to n. Result is
-// not specified in n does not represent a number within the range of Uint128
-// values.
-func NewUint128FromFloat32(n float32) (r Uint128) {
-	if n >= 0 {
-		if n <= math.MaxUint64 {
-			return NewUint128FromUint64(uint64(n))
-		}
-
-		f := big.NewFloat(float64(n))
-		bi, _ := f.Int(nil)
-		r.SetBigInt(bi)
-	}
-	return r
-}
-
-// NewUint128FromFloat64 returns a new Uint128 value initialized to n. Result is
-// not specified in n does not represent a number within the range of Uint128
-// values.
-func NewUint128FromFloat64(n float64) (r Uint128) {
-	if n >= 0 && n <= maxUint128 {
-		if n <= math.MaxUint64 {
-			return NewUint128FromUint64(uint64(n))
-		}
-
-		f := big.NewFloat(n)
-		bi, _ := f.Int(nil)
-		r.SetBigInt(bi)
-	}
-	return r
-}
-
-// SetBigInt sets x to y, returns x and an error, if any.
-func (x *Uint128) SetBigInt(y *big.Int) (r Uint128, err error) {
-	if y.Sign() < 0 || y.Cmp(MaxUint128) > 0 {
-		return *x, fmt.Errorf("%T.SetInt: overflow", x)
-	}
-
-	var z big.Int
-	z.Set(y)
-	r.Lo = z.Uint64()
-	z.Rsh(&z, 64)
-	r.Hi = z.Uint64()
-	*x = r
-	return r, nil
-}