[chore] update dependencies (#4188)

Update dependencies:
- github.com/gin-gonic/gin v1.10.0 -> v1.10.1
- github.com/gin-contrib/sessions v1.10.3 -> v1.10.4
- github.com/jackc/pgx/v5 v5.7.4 -> v5.7.5
- github.com/minio/minio-go/v7 v7.0.91 -> v7.0.92
- github.com/pquerna/otp v1.4.0 -> v1.5.0
- github.com/tdewolff/minify/v2 v2.23.5 -> v2.23.8
- github.com/yuin/goldmark v1.7.11 -> v1.7.12
- go.opentelemetry.io/otel{,/*} v1.35.0 -> v1.36.0
- modernc.org/sqlite v1.37.0 -> v1.37.1

Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4188
Reviewed-by: Daenney <daenney@noreply.codeberg.org>
Co-authored-by: kim <grufwub@gmail.com>
Co-committed-by: kim <grufwub@gmail.com>

1 files changed, 936 insertions, 15 deletions

diff --git a/vendor/modernc.org/libc/libc.go b/vendor/modernc.org/libc/libc.go
index 2a7988bd4..dab50ebf3 100644
--- a/vendor/modernc.org/libc/libc.go
+++ b/vendor/modernc.org/libc/libc.go
@@ -4,11 +4,9 @@
 
 //go:build !linux || mips64le
 
-//go.generate echo package libc > ccgo.go
-//go:generate go fmt ./...
-
-// Package libc provides run time support for ccgo generated programs and
-// implements selected parts of the C standard library.
+// go.generate echo package libc > ccgo.go
+//
+//go:generate go fmt -l -s -w ./...
 package libc // import "modernc.org/libc"
 
 //TODO use O_RDONLY etc. from fcntl header
@@ -1952,7 +1950,7 @@ func getLocalLocation() (loc *gotime.Location) {
 }
 
 // time_t mktime(struct tm *tm);
-func Xmktime(t *TLS, ptm uintptr) time.Time_t {
+func Xmktime(t *TLS, ptm uintptr) (r time.Time_t) {
 	if __ccgo_strace {
 		trc("t=%v ptm=%v, (%v:)", t, ptm, origin(2))
 	}
@@ -1969,7 +1967,8 @@ func Xmktime(t *TLS, ptm uintptr) time.Time_t {
 	)
 	(*time.Tm)(unsafe.Pointer(ptm)).Ftm_wday = int32(tt.Weekday())
 	(*time.Tm)(unsafe.Pointer(ptm)).Ftm_yday = int32(tt.YearDay() - 1)
-	return time.Time_t(tt.Unix())
+	r = time.Time_t(tt.Unix())
+	return r
 }
 
 // char *strpbrk(const char *s, const char *accept);
@@ -2314,14 +2313,6 @@ func Xwcwidth(t *TLS, c wchar_t) int32 {
 	panic(todo(""))
 }
 
-// int clock_gettime(clockid_t clk_id, struct timespec *tp);
-func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32 {
-	if __ccgo_strace {
-		trc("t=%v clk_id=%v tp=%v, (%v:)", t, clk_id, tp, origin(2))
-	}
-	panic(todo(""))
-}
-
 // AtExit will attempt to run f at process exit. The execution cannot be
 // guaranteed, neither its ordering with respect to any other handlers
 // registered by AtExit.
@@ -2650,3 +2641,933 @@ func Xlrint(tls *TLS, x float64) (r long) {
 	}
 	return long(Xrint(tls, x))
 }
+
+func X__builtin_trunc(tls *TLS, x float64) (r float64) {
+	return Xtrunc(tls, x)
+}
+
+func X__builtin_fmin(tls *TLS, x float64, y float64) (r float64) {
+	return Xfmin(tls, x, y)
+}
+
+func Xfmin(tls *TLS, x float64, y float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var v1, v10, v3, v5, v7 uint64
+	var v12, v9 float64
+	var _ /* __u at bp+0 */ struct {
+		F__i [0]uint64
+		F__f float64
+	}
+	_, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9
+	*(*float64)(unsafe.Pointer(bp)) = x
+	v1 = *(*uint64)(unsafe.Pointer(bp))
+	goto _2
+_2:
+	if BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 {
+		return y
+	}
+	*(*float64)(unsafe.Pointer(bp)) = y
+	v3 = *(*uint64)(unsafe.Pointer(bp))
+	goto _4
+_4:
+	if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 {
+		return x
+	}
+	/* handle signed zeros, see C99 Annex F.9.9.2 */
+	*(*float64)(unsafe.Pointer(bp)) = x
+	v5 = *(*uint64)(unsafe.Pointer(bp))
+	goto _6
+_6:
+	*(*float64)(unsafe.Pointer(bp)) = y
+	v7 = *(*uint64)(unsafe.Pointer(bp))
+	goto _8
+_8:
+	if Int32FromUint64(v5>>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) {
+		*(*float64)(unsafe.Pointer(bp)) = x
+		v10 = *(*uint64)(unsafe.Pointer(bp))
+		goto _11
+	_11:
+		if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 {
+			v9 = x
+		} else {
+			v9 = y
+		}
+		return v9
+	}
+	if x < y {
+		v12 = x
+	} else {
+		v12 = y
+	}
+	return v12
+}
+
+func Xfminf(tls *TLS, x float32, y float32) (r float32) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var v1, v10, v3, v5, v7 uint32
+	var v12, v9 float32
+	var _ /* __u at bp+0 */ struct {
+		F__i [0]uint32
+		F__f float32
+	}
+	_, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9
+	*(*float32)(unsafe.Pointer(bp)) = x
+	v1 = *(*uint32)(unsafe.Pointer(bp))
+	goto _2
+_2:
+	if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 {
+		return y
+	}
+	*(*float32)(unsafe.Pointer(bp)) = y
+	v3 = *(*uint32)(unsafe.Pointer(bp))
+	goto _4
+_4:
+	if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 {
+		return x
+	}
+	/* handle signed zeros, see C99 Annex F.9.9.2 */
+	*(*float32)(unsafe.Pointer(bp)) = x
+	v5 = *(*uint32)(unsafe.Pointer(bp))
+	goto _6
+_6:
+	*(*float32)(unsafe.Pointer(bp)) = y
+	v7 = *(*uint32)(unsafe.Pointer(bp))
+	goto _8
+_8:
+	if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) {
+		*(*float32)(unsafe.Pointer(bp)) = x
+		v10 = *(*uint32)(unsafe.Pointer(bp))
+		goto _11
+	_11:
+		if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 {
+			v9 = x
+		} else {
+			v9 = y
+		}
+		return v9
+	}
+	if x < y {
+		v12 = x
+	} else {
+		v12 = y
+	}
+	return v12
+}
+
+func Xfminl(tls *TLS, x float64, y float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	return Xfmin(tls, x, y)
+}
+
+func Xfmax(tls *TLS, x float64, y float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var v1, v10, v3, v5, v7 uint64
+	var v12, v9 float64
+	var _ /* __u at bp+0 */ struct {
+		F__i [0]uint64
+		F__f float64
+	}
+	_, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9
+	*(*float64)(unsafe.Pointer(bp)) = x
+	v1 = *(*uint64)(unsafe.Pointer(bp))
+	goto _2
+_2:
+	if BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 {
+		return y
+	}
+	*(*float64)(unsafe.Pointer(bp)) = y
+	v3 = *(*uint64)(unsafe.Pointer(bp))
+	goto _4
+_4:
+	if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 {
+		return x
+	}
+	/* handle signed zeros, see C99 Annex F.9.9.2 */
+	*(*float64)(unsafe.Pointer(bp)) = x
+	v5 = *(*uint64)(unsafe.Pointer(bp))
+	goto _6
+_6:
+	*(*float64)(unsafe.Pointer(bp)) = y
+	v7 = *(*uint64)(unsafe.Pointer(bp))
+	goto _8
+_8:
+	if Int32FromUint64(v5>>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) {
+		*(*float64)(unsafe.Pointer(bp)) = x
+		v10 = *(*uint64)(unsafe.Pointer(bp))
+		goto _11
+	_11:
+		if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 {
+			v9 = y
+		} else {
+			v9 = x
+		}
+		return v9
+	}
+	if x < y {
+		v12 = y
+	} else {
+		v12 = x
+	}
+	return v12
+}
+
+func Xfmaxf(tls *TLS, x float32, y float32) (r float32) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var v1, v10, v3, v5, v7 uint32
+	var v12, v9 float32
+	var _ /* __u at bp+0 */ struct {
+		F__i [0]uint32
+		F__f float32
+	}
+	_, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9
+	*(*float32)(unsafe.Pointer(bp)) = x
+	v1 = *(*uint32)(unsafe.Pointer(bp))
+	goto _2
+_2:
+	if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 {
+		return y
+	}
+	*(*float32)(unsafe.Pointer(bp)) = y
+	v3 = *(*uint32)(unsafe.Pointer(bp))
+	goto _4
+_4:
+	if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 {
+		return x
+	}
+	/* handle signed zeroes, see C99 Annex F.9.9.2 */
+	*(*float32)(unsafe.Pointer(bp)) = x
+	v5 = *(*uint32)(unsafe.Pointer(bp))
+	goto _6
+_6:
+	*(*float32)(unsafe.Pointer(bp)) = y
+	v7 = *(*uint32)(unsafe.Pointer(bp))
+	goto _8
+_8:
+	if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) {
+		*(*float32)(unsafe.Pointer(bp)) = x
+		v10 = *(*uint32)(unsafe.Pointer(bp))
+		goto _11
+	_11:
+		if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 {
+			v9 = y
+		} else {
+			v9 = x
+		}
+		return v9
+	}
+	if x < y {
+		v12 = y
+	} else {
+		v12 = x
+	}
+	return v12
+}
+
+func Xfmaxl(tls *TLS, x float64, y float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v y=%v, (%v:)", tls, x, y, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	return Xfmax(tls, x, y)
+}
+
+func X__builtin_fmax(tls *TLS, x float64, y float64) (r float64) {
+	return Xfmax(tls, x, y)
+}
+
+func Xexpm1(tls *TLS, x3 float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var c, e, hfx, hi, hxs, lo, r1, t, twopk, y3 Tdouble_t
+	var hx Tuint32_t
+	var k, sign int32
+	var y float32
+	var y1, y2, v3 float64
+	var v1 uint64
+	var _ /* __u at bp+0 */ struct {
+		F__i [0]uint64
+		F__f float64
+	}
+	var _ /* u at bp+8 */ struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	}
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, e, hfx, hi, hx, hxs, k, lo, r1, sign, t, twopk, y, y1, y2, y3, v1, v3
+	*(*struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	})(unsafe.Pointer(bp + 8)) = struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	}{}
+	*(*float64)(unsafe.Pointer(bp + 8)) = x3
+	hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) >> int32(32) & uint64(0x7fffffff))
+	sign = Int32FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp + 8)) >> int32(63))
+	/* filter out huge and non-finite argument */
+	if hx >= uint32(0x4043687A) { /* if |x|>=56*ln2 */
+		*(*float64)(unsafe.Pointer(bp)) = x3
+		v1 = *(*uint64)(unsafe.Pointer(bp))
+		goto _2
+	_2:
+		if BoolInt32(v1&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<<Int32FromInt32(52)) != 0 {
+			return x3
+		}
+		if sign != 0 {
+			return float64(-Int32FromInt32(1))
+		}
+		if x3 > _o_threshold {
+			x3 *= float64(8.98846567431158e+307)
+			return x3
+		}
+	}
+	/* argument reduction */
+	if hx > uint32(0x3fd62e42) { /* if  |x| > 0.5 ln2 */
+		if hx < uint32(0x3FF0A2B2) { /* and |x| < 1.5 ln2 */
+			if !(sign != 0) {
+				hi = x3 - _ln2_hi
+				lo = _ln2_lo
+				k = int32(1)
+			} else {
+				hi = x3 + _ln2_hi
+				lo = -_ln2_lo
+				k = -int32(1)
+			}
+		} else {
+			if sign != 0 {
+				v3 = -Float64FromFloat64(0.5)
+			} else {
+				v3 = float64(0.5)
+			}
+			k = int32(float64(_invln2*x3) + v3)
+			t = float64(k)
+			hi = x3 - float64(t*_ln2_hi) /* t*ln2_hi is exact here */
+			lo = Tdouble_t(t * _ln2_lo)
+		}
+		x3 = hi - lo
+		c = hi - x3 - lo
+	} else {
+		if hx < uint32(0x3c900000) { /* |x| < 2**-54, return x */
+			if hx < uint32(0x00100000) {
+				if uint64(4) == uint64(4) {
+					y = float32(x3)
+				} else {
+					if uint64(4) == uint64(8) {
+						y1 = float64(float32(x3))
+					} else {
+						y2 = float64(float32(x3))
+					}
+				}
+			}
+			return x3
+		} else {
+			k = 0
+		}
+	}
+	/* x is now in primary range */
+	hfx = Tdouble_t(float64(0.5) * x3)
+	hxs = Tdouble_t(x3 * hfx)
+	r1 = float64(1) + float64(hxs*(_Q1+float64(hxs*(_Q2+float64(hxs*(_Q3+float64(hxs*(_Q4+float64(hxs*_Q5)))))))))
+	t = float64(3) - float64(r1*hfx)
+	e = Tdouble_t(hxs * ((r1 - t) / (Float64FromFloat64(6) - float64(x3*t))))
+	if k == 0 { /* c is 0 */
+		return x3 - (float64(x3*e) - hxs)
+	}
+	e = float64(x3*(e-c)) - c
+	e -= hxs
+	/* exp(x) ~ 2^k (Xreduced - e + 1) */
+	if k == -int32(1) {
+		return float64(float64(0.5)*(x3-e)) - float64(0.5)
+	}
+	if k == int32(1) {
+		if x3 < -Float64FromFloat64(0.25) {
+			return float64(-Float64FromFloat64(2) * (e - (x3 + Float64FromFloat64(0.5))))
+		}
+		return float64(1) + float64(float64(2)*(x3-e))
+	}
+	*(*Tuint64_t)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(Int32FromInt32(0x3ff)+k) << int32(52) /* 2^k */
+	twopk = *(*float64)(unsafe.Pointer(bp + 8))
+	if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */
+		y3 = x3 - e + float64(1)
+		if k == int32(1024) {
+			y3 = Tdouble_t(Tdouble_t(y3*float64(2)) * float64(8.98846567431158e+307))
+		} else {
+			y3 = Tdouble_t(y3 * twopk)
+		}
+		return y3 - float64(1)
+	}
+	*(*Tuint64_t)(unsafe.Pointer(bp + 8)) = Uint64FromInt32(Int32FromInt32(0x3ff)-k) << int32(52) /* 2^-k */
+	if k < int32(20) {
+		y3 = Tdouble_t((x3 - e + (Float64FromInt32(1) - *(*float64)(unsafe.Pointer(bp + 8)))) * twopk)
+	} else {
+		y3 = Tdouble_t((x3 - (e + *(*float64)(unsafe.Pointer(bp + 8))) + Float64FromInt32(1)) * twopk)
+	}
+	return y3
+}
+
+var _ln2_hi1 = float32(0.69313812256)    /* 0x3f317180 */
+var _ln2_lo1 = float32(9.0580006145e-06) /* 0x3717f7d1 */
+var _invln21 = float32(1.4426950216)     /* 0x3fb8aa3b */
+/*
+ * Domain [-0.34568, 0.34568], range ~[-6.694e-10, 6.696e-10]:
+ * |6 / x * (1 + 2 * (1 / (exp(x) - 1) - 1 / x)) - q(x)| < 2**-30.04
+ * Scaled coefficients: Qn_here = 2**n * Qn_for_q (see s_expm1.c):
+ */
+var _Q11 = float32(-Float64FromFloat64(0.033333212137)) /* -0x888868.0p-28 */
+var _Q21 = float32(0.0015807170421)                     /*  0xcf3010.0p-33 */
+
+func Xexpm1f(tls *TLS, x3 float32) (r float32) {
+	if __ccgo_strace {
+		trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var c, e, hfx, hi, hxs, lo, r1, t, twopk, y3 Tfloat_t
+	var hx Tuint32_t
+	var k, sign int32
+	var y, v1 float32
+	var y1, y2 float64
+	var _ /* u at bp+0 */ struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	}
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, e, hfx, hi, hx, hxs, k, lo, r1, sign, t, twopk, y, y1, y2, y3, v1
+	*(*struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	})(unsafe.Pointer(bp)) = struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	}{}
+	*(*float32)(unsafe.Pointer(bp)) = x3
+	hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff)
+	sign = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(bp)) >> int32(31))
+	/* filter out huge and non-finite argument */
+	if hx >= uint32(0x4195b844) { /* if |x|>=27*ln2 */
+		if hx > uint32(0x7f800000) { /* NaN */
+			return x3
+		}
+		if sign != 0 {
+			return float32(-Int32FromInt32(1))
+		}
+		if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */
+			x3 *= Float32FromFloat32(1.7014118346046923e+38)
+			return x3
+		}
+	}
+	/* argument reduction */
+	if hx > uint32(0x3eb17218) { /* if  |x| > 0.5 ln2 */
+		if hx < uint32(0x3F851592) { /* and |x| < 1.5 ln2 */
+			if !(sign != 0) {
+				hi = x3 - _ln2_hi1
+				lo = _ln2_lo1
+				k = int32(1)
+			} else {
+				hi = x3 + _ln2_hi1
+				lo = -_ln2_lo1
+				k = -int32(1)
+			}
+		} else {
+			if sign != 0 {
+				v1 = -Float32FromFloat32(0.5)
+			} else {
+				v1 = Float32FromFloat32(0.5)
+			}
+			k = int32(float32(_invln21*x3) + v1)
+			t = float32(k)
+			hi = x3 - float32(t*_ln2_hi1) /* t*ln2_hi is exact here */
+			lo = Tfloat_t(t * _ln2_lo1)
+		}
+		x3 = hi - lo
+		c = hi - x3 - lo
+	} else {
+		if hx < uint32(0x33000000) { /* when |x|<2**-25, return x */
+			if hx < uint32(0x00800000) {
+				if uint64(4) == uint64(4) {
+					y = float32(x3 * x3)
+				} else {
+					if uint64(4) == uint64(8) {
+						y1 = float64(x3 * x3)
+					} else {
+						y2 = float64(x3 * x3)
+					}
+				}
+			}
+			return x3
+		} else {
+			k = 0
+		}
+	}
+	/* x is now in primary range */
+	hfx = Tfloat_t(Float32FromFloat32(0.5) * x3)
+	hxs = Tfloat_t(x3 * hfx)
+	r1 = Float32FromFloat32(1) + float32(hxs*(_Q11+float32(hxs*_Q21)))
+	t = Float32FromFloat32(3) - float32(r1*hfx)
+	e = Tfloat_t(hxs * ((r1 - t) / (Float32FromFloat32(6) - float32(x3*t))))
+	if k == 0 { /* c is 0 */
+		return x3 - (float32(x3*e) - hxs)
+	}
+	e = float32(x3*(e-c)) - c
+	e -= hxs
+	/* exp(x) ~ 2^k (Xreduced - e + 1) */
+	if k == -int32(1) {
+		return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5)
+	}
+	if k == int32(1) {
+		if x3 < -Float32FromFloat32(0.25) {
+			return float32(-Float32FromFloat32(2) * (e - (x3 + Float32FromFloat32(0.5))))
+		}
+		return Float32FromFloat32(1) + float32(Float32FromFloat32(2)*(x3-e))
+	}
+	*(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) + k) << int32(23)) /* 2^k */
+	twopk = *(*float32)(unsafe.Pointer(bp))
+	if k < 0 || k > int32(56) { /* suffice to return exp(x)-1 */
+		y3 = x3 - e + Float32FromFloat32(1)
+		if k == int32(128) {
+			y3 = Tfloat_t(Tfloat_t(y3*Float32FromFloat32(2)) * Float32FromFloat32(1.7014118346046923e+38))
+		} else {
+			y3 = Tfloat_t(y3 * twopk)
+		}
+		return y3 - Float32FromFloat32(1)
+	}
+	*(*Tuint32_t)(unsafe.Pointer(bp)) = Uint32FromInt32((int32(0x7f) - k) << int32(23)) /* 2^-k */
+	if k < int32(23) {
+		y3 = Tfloat_t((x3 - e + (Float32FromInt32(1) - *(*float32)(unsafe.Pointer(bp)))) * twopk)
+	} else {
+		y3 = Tfloat_t((x3 - (e + *(*float32)(unsafe.Pointer(bp))) + Float32FromInt32(1)) * twopk)
+	}
+	return y3
+}
+
+func Xexpm1l(tls *TLS, x float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	return Xexpm1(tls, x)
+}
+
+type Tdouble_t = float64
+type Tuint32_t = uint32
+type Tuint64_t = uint64
+
+var _o_threshold = float64(709.782712893384)  /* 0x40862E42, 0xFEFA39EF */
+var _ln2_hi = float64(0.6931471803691238)     /* 0x3fe62e42, 0xfee00000 */
+var _ln2_lo = float64(1.9082149292705877e-10) /* 0x3dea39ef, 0x35793c76 */
+var _invln2 = float64(1.4426950408889634)     /* 0x3ff71547, 0x652b82fe */
+/* Scaled Q's: Qn_here = 2**n * Qn_above, for R(2*z) where z = hxs = x*x/2: */
+var _Q1 = -Float64FromFloat64(0.03333333333333313)    /* BFA11111 111110F4 */
+var _Q2 = float64(0.0015873015872548146)              /* 3F5A01A0 19FE5585 */
+var _Q3 = -Float64FromFloat64(7.93650757867488e-05)   /* BF14CE19 9EAADBB7 */
+var _Q4 = float64(4.008217827329362e-06)              /* 3ED0CFCA 86E65239 */
+var _Q5 = -Float64FromFloat64(2.0109921818362437e-07) /* BE8AFDB7 6E09C32D */
+
+var _ln2_hi2 = float64(0.6931471803691238)     /* 3fe62e42 fee00000 */
+var _ln2_lo2 = float64(1.9082149292705877e-10) /* 3dea39ef 35793c76 */
+var _Lg12 = float64(0.6666666666666735)        /* 3FE55555 55555593 */
+var _Lg22 = float64(0.3999999999940942)        /* 3FD99999 9997FA04 */
+var _Lg32 = float64(0.2857142874366239)        /* 3FD24924 94229359 */
+var _Lg42 = float64(0.22222198432149784)       /* 3FCC71C5 1D8E78AF */
+var _Lg51 = float64(0.1818357216161805)        /* 3FC74664 96CB03DE */
+var _Lg61 = float64(0.15313837699209373)       /* 3FC39A09 D078C69F */
+var _Lg71 = float64(0.14798198605116586)       /* 3FC2F112 DF3E5244 */
+
+func Xlog1p(tls *TLS, x3 float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var R, c, dk, f, hfsq, s, t1, t2, w, z Tdouble_t
+	var hu, hx Tuint32_t
+	var k int32
+	var y float32
+	var y1, y2, v1 float64
+	var _ /* u at bp+0 */ struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	}
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = R, c, dk, f, hfsq, hu, hx, k, s, t1, t2, w, y, y1, y2, z, v1
+	*(*struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	})(unsafe.Pointer(bp)) = struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	}{}
+	*(*float64)(unsafe.Pointer(bp)) = x3
+	hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32))
+	k = int32(1)
+	if hx < uint32(0x3fda827a) || hx>>int32(31) != 0 { /* 1+x < sqrt(2)+ */
+		if hx >= uint32(0xbff00000) { /* x <= -1.0 */
+			if x3 == float64(-Int32FromInt32(1)) {
+				return x3 / float64(0)
+			} /* log1p(-1) = -inf */
+			return (x3 - x3) / float64(0) /* log1p(x<-1) = NaN */
+		}
+		if hx<<int32(1) < Uint32FromInt32(Int32FromInt32(0x3ca00000)<<Int32FromInt32(1)) { /* |x| < 2**-53 */
+			/* underflow if subnormal */
+			if hx&uint32(0x7ff00000) == uint32(0) {
+				if uint64(4) == uint64(4) {
+					y = float32(x3)
+				} else {
+					if uint64(4) == uint64(8) {
+						y1 = float64(float32(x3))
+					} else {
+						y2 = float64(float32(x3))
+					}
+				}
+			}
+			return x3
+		}
+		if hx <= uint32(0xbfd2bec4) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */
+			k = 0
+			c = Float64FromInt32(0)
+			f = x3
+		}
+	} else {
+		if hx >= uint32(0x7ff00000) {
+			return x3
+		}
+	}
+	if k != 0 {
+		*(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3
+		hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32))
+		hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e))
+		k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff)
+		/* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
+		if k < int32(54) {
+			if k >= int32(2) {
+				v1 = Float64FromInt32(1) - (*(*float64)(unsafe.Pointer(bp)) - x3)
+			} else {
+				v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1))
+			}
+			c = v1
+			c /= *(*float64)(unsafe.Pointer(bp))
+		} else {
+			c = Float64FromInt32(0)
+		}
+		/* reduce u into [sqrt(2)/2, sqrt(2)] */
+		hu = hu&uint32(0x000fffff) + uint32(0x3fe6a09e)
+		*(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hu)<<int32(32) | *(*Tuint64_t)(unsafe.Pointer(bp))&uint64(0xffffffff)
+		f = *(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)
+	}
+	hfsq = Tdouble_t(float64(float64(0.5)*f) * f)
+	s = f / (Float64FromFloat64(2) + f)
+	z = Tdouble_t(s * s)
+	w = Tdouble_t(z * z)
+	t1 = Tdouble_t(w * (_Lg22 + float64(w*(_Lg42+float64(w*_Lg61)))))
+	t2 = Tdouble_t(z * (_Lg12 + float64(w*(_Lg32+float64(w*(_Lg51+float64(w*_Lg71)))))))
+	R = t2 + t1
+	dk = float64(k)
+	return Tdouble_t(s*(hfsq+R)) + (Tdouble_t(dk*_ln2_lo2) + c) - hfsq + f + Tdouble_t(dk*_ln2_hi2)
+}
+
+var _ln2_hi3 = float32(0.69313812256)    /* 0x3f317180 */
+var _ln2_lo3 = float32(9.0580006145e-06) /* 0x3717f7d1 */
+/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */
+var _Lg13 = float32(0.6666666269302368)  /* 0.66666662693 */
+var _Lg23 = float32(0.40000972151756287) /* 0.40000972152 */
+var _Lg33 = float32(0.2849878668785095)  /* 0.28498786688 */
+var _Lg43 = float32(0.24279078841209412) /* 0.24279078841 */
+
+func Xlog1pf(tls *TLS, x3 float32) (r float32) {
+	if __ccgo_strace {
+		trc("tls=%v x3=%v, (%v:)", tls, x3, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var R, c, dk, f, hfsq, s, t1, t2, w, z Tfloat_t
+	var iu, ix Tuint32_t
+	var k int32
+	var y, v1 float32
+	var y1, y2 float64
+	var _ /* u at bp+0 */ struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	}
+	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = R, c, dk, f, hfsq, iu, ix, k, s, t1, t2, w, y, y1, y2, z, v1
+	*(*struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	})(unsafe.Pointer(bp)) = struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	}{}
+	*(*float32)(unsafe.Pointer(bp)) = x3
+	ix = *(*Tuint32_t)(unsafe.Pointer(bp))
+	k = int32(1)
+	if ix < uint32(0x3ed413d0) || ix>>int32(31) != 0 { /* 1+x < sqrt(2)+  */
+		if ix >= uint32(0xbf800000) { /* x <= -1.0 */
+			if x3 == float32(-Int32FromInt32(1)) {
+				return x3 / Float32FromFloat32(0)
+			} /* log1p(-1)=+inf */
+			return (x3 - x3) / Float32FromFloat32(0) /* log1p(x<-1)=NaN */
+		}
+		if ix<<int32(1) < Uint32FromInt32(Int32FromInt32(0x33800000)<<Int32FromInt32(1)) { /* |x| < 2**-24 */
+			/* underflow if subnormal */
+			if ix&uint32(0x7f800000) == uint32(0) {
+				if uint64(4) == uint64(4) {
+					y = float32(x3 * x3)
+				} else {
+					if uint64(4) == uint64(8) {
+						y1 = float64(x3 * x3)
+					} else {
+						y2 = float64(x3 * x3)
+					}
+				}
+			}
+			return x3
+		}
+		if ix <= uint32(0xbe95f619) { /* sqrt(2)/2- <= 1+x < sqrt(2)+ */
+			k = 0
+			c = Float32FromInt32(0)
+			f = x3
+		}
+	} else {
+		if ix >= uint32(0x7f800000) {
+			return x3
+		}
+	}
+	if k != 0 {
+		*(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3
+		iu = *(*Tuint32_t)(unsafe.Pointer(bp))
+		iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3))
+		k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f)
+		/* correction term ~ log(1+x)-log(u), avoid underflow in c/u */
+		if k < int32(25) {
+			if k >= int32(2) {
+				v1 = Float32FromInt32(1) - (*(*float32)(unsafe.Pointer(bp)) - x3)
+			} else {
+				v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1))
+			}
+			c = v1
+			c /= *(*float32)(unsafe.Pointer(bp))
+		} else {
+			c = Float32FromInt32(0)
+		}
+		/* reduce u into [sqrt(2)/2, sqrt(2)] */
+		iu = iu&uint32(0x007fffff) + uint32(0x3f3504f3)
+		*(*Tuint32_t)(unsafe.Pointer(bp)) = iu
+		f = *(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)
+	}
+	s = f / (Float32FromFloat32(2) + f)
+	z = Tfloat_t(s * s)
+	w = Tfloat_t(z * z)
+	t1 = Tfloat_t(w * (_Lg23 + float32(w*_Lg43)))
+	t2 = Tfloat_t(z * (_Lg13 + float32(w*_Lg33)))
+	R = t2 + t1
+	hfsq = Tfloat_t(float32(Float32FromFloat32(0.5)*f) * f)
+	dk = float32(k)
+	return Tfloat_t(s*(hfsq+R)) + (Tfloat_t(dk*_ln2_lo3) + c) - hfsq + f + Tfloat_t(dk*_ln2_hi3)
+}
+
+func Xlog1pl(tls *TLS, x float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	return Xlog1p(tls, x)
+}
+
+type Tfloat_t = float32
+
+var _B1 = uint32(715094163) /* B1 = (1023-1023/3-0.03306235651)*2**20 */
+var _B2 = uint32(696219795) /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
+
+// C documentation
+//
+//	/* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */
+
+var _P0 = float64(1.87595182427177)               /* 0x3ffe03e6, 0x0f61e692 */
+var _P1 = -Float64FromFloat64(1.8849797954337717) /* 0xbffe28e0, 0x92f02420 */
+var _P2 = float64(1.6214297201053545)             /* 0x3ff9f160, 0x4a49d6c2 */
+var _P3 = -Float64FromFloat64(0.758397934778766)  /* 0xbfe844cb, 0xbee751d9 */
+var _P4 = float64(0.14599619288661245)            /* 0x3fc2b000, 0xd4e4edd7 */
+
+func Xcbrt(tls *TLS, x float64) (r1 float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r1) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var hx Tuint32_t
+	var r, s, t, w Tdouble_t
+	var p1 uintptr
+	var _ /* u at bp+0 */ struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	}
+	_, _, _, _, _, _ = hx, r, s, t, w, p1
+	*(*struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	})(unsafe.Pointer(bp)) = struct {
+		Fi [0]Tuint64_t
+		Ff float64
+	}{}
+	*(*float64)(unsafe.Pointer(bp)) = x
+	hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff))
+	if hx >= uint32(0x7ff00000) { /* cbrt(NaN,INF) is itself */
+		return x + x
+	}
+	/*
+	 * Rough cbrt to 5 bits:
+	 *    cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)
+	 * where e is integral and >= 0, m is real and in [0, 1), and "/" and
+	 * "%" are integer division and modulus with rounding towards minus
+	 * infinity.  The RHS is always >= the LHS and has a maximum relative
+	 * error of about 1 in 16.  Adding a bias of -0.03306235651 to the
+	 * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE
+	 * floating point representation, for finite positive normal values,
+	 * ordinary integer divison of the value in bits magically gives
+	 * almost exactly the RHS of the above provided we first subtract the
+	 * exponent bias (1023 for doubles) and later add it back.  We do the
+	 * subtraction virtually to keep e >= 0 so that ordinary integer
+	 * division rounds towards minus infinity; this is also efficient.
+	 */
+	if hx < uint32(0x00100000) { /* zero or subnormal? */
+		*(*float64)(unsafe.Pointer(bp)) = float64(x * float64(1.8014398509481984e+16))
+		hx = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32) & uint64(0x7fffffff))
+		if hx == uint32(0) {
+			return x
+		} /* cbrt(0) is itself */
+		hx = hx/uint32(3) + _B2
+	} else {
+		hx = hx/uint32(3) + _B1
+	}
+	p1 = bp
+	*(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63)))
+	*(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32)
+	t = *(*float64)(unsafe.Pointer(bp))
+	/*
+	 * New cbrt to 23 bits:
+	 *    cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x)
+	 * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r)
+	 * to within 2**-23.5 when |r - 1| < 1/10.  The rough approximation
+	 * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this
+	 * gives us bounds for r = t**3/x.
+	 *
+	 * Try to optimize for parallel evaluation as in __tanf.c.
+	 */
+	r = Tdouble_t(Tdouble_t(t*t) * (t / x))
+	t = Tdouble_t(t * (_P0 + float64(r*(_P1+float64(r*_P2))) + float64(Tdouble_t(Tdouble_t(r*r)*r)*(_P3+float64(r*_P4)))))
+	/*
+	 * Round t away from zero to 23 bits (sloppily except for ensuring that
+	 * the result is larger in magnitude than cbrt(x) but not much more than
+	 * 2 23-bit ulps larger).  With rounding towards zero, the error bound
+	 * would be ~5/6 instead of ~4/6.  With a maximum error of 2 23-bit ulps
+	 * in the rounded t, the infinite-precision error in the Newton
+	 * approximation barely affects third digit in the final error
+	 * 0.667; the error in the rounded t can be up to about 3 23-bit ulps
+	 * before the final error is larger than 0.667 ulps.
+	 */
+	*(*float64)(unsafe.Pointer(bp)) = t
+	*(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp))+Uint64FromUint32(0x80000000)) & uint64(0xffffffffc0000000)
+	t = *(*float64)(unsafe.Pointer(bp))
+	/* one step Newton iteration to 53 bits with error < 0.667 ulps */
+	s = Tdouble_t(t * t)   /* t*t is exact */
+	r = x / s              /* error <= 0.5 ulps; |r| < |t| */
+	w = t + t              /* t+t is exact */
+	r = (r - t) / (w + r)  /* r-t is exact; w+r ~= 3*t */
+	t = t + Tdouble_t(t*r) /* error <= 0.5 + 0.5/3 + epsilon */
+	return t
+}
+
+var _B11 = uint32(709958130) /* B1 = (127-127.0/3-0.03306235651)*2**23 */
+var _B21 = uint32(642849266) /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */
+
+func Xcbrtf(tls *TLS, x float32) (r1 float32) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r1) }()
+	}
+	bp := tls.Alloc(16)
+	defer tls.Free(16)
+	var T, r Tdouble_t
+	var hx Tuint32_t
+	var _ /* u at bp+0 */ struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	}
+	_, _, _ = T, hx, r
+	*(*struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	})(unsafe.Pointer(bp)) = struct {
+		Fi [0]Tuint32_t
+		Ff float32
+	}{}
+	*(*float32)(unsafe.Pointer(bp)) = x
+	hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff)
+	if hx >= uint32(0x7f800000) { /* cbrt(NaN,INF) is itself */
+		return x + x
+	}
+	/* rough cbrt to 5 bits */
+	if hx < uint32(0x00800000) { /* zero or subnormal? */
+		if hx == uint32(0) {
+			return x
+		} /* cbrt(+-0) is itself */
+		*(*float32)(unsafe.Pointer(bp)) = float32(x * Float32FromFloat32(1.6777216e+07))
+		hx = *(*Tuint32_t)(unsafe.Pointer(bp)) & uint32(0x7fffffff)
+		hx = hx/uint32(3) + _B21
+	} else {
+		hx = hx/uint32(3) + _B11
+	}
+	*(*Tuint32_t)(unsafe.Pointer(bp)) &= uint32(0x80000000)
+	*(*Tuint32_t)(unsafe.Pointer(bp)) |= hx
+	/*
+	 * First step Newton iteration (solving t*t-x/t == 0) to 16 bits.  In
+	 * double precision so that its terms can be arranged for efficiency
+	 * without causing overflow or underflow.
+	 */
+	T = float64(*(*float32)(unsafe.Pointer(bp)))
+	r = Tdouble_t(Tdouble_t(T*T) * T)
+	T = Tdouble_t(T*(float64(x)+float64(x)+r)) / (float64(x) + r + r)
+	/*
+	 * Second step Newton iteration to 47 bits.  In double precision for
+	 * efficiency and accuracy.
+	 */
+	r = Tdouble_t(Tdouble_t(T*T) * T)
+	T = Tdouble_t(T*(float64(x)+float64(x)+r)) / (float64(x) + r + r)
+	/* rounding to 24 bits is perfect in round-to-nearest mode */
+	return float32(T)
+}
+
+func Xcbrtl(tls *TLS, x float64) (r float64) {
+	if __ccgo_strace {
+		trc("tls=%v x=%v, (%v:)", tls, x, origin(2))
+		defer func() { trc("-> %v", r) }()
+	}
+	return Xcbrt(tls, x)
+}