````// Copyright 2021 The Go 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 strconv`

`import (`
`	"math/bits"`
`)`

`// binary to decimal conversion using the Ryū algorithm.`
`//`
`// See Ulf Adams, "Ryū: Fast Float-to-String Conversion" (doi:10.1145/3192366.3192369)`
`//`
`// Fixed precision formatting is a variant of the original paper's`
`// algorithm, where a single multiplication by 10^k is required,`
`// sharing the same rounding guarantees.`

`// ryuFtoaFixed32 formats mant*(2^exp) with prec decimal digits.`
`func ryuFtoaFixed32(d *decimalSlice, mant uint32, exp int, prec int) {`
`	if prec < 0 {`
`		panic("ryuFtoaFixed32 called with negative prec")`
`	}`
`	if prec > 9 {`
`		panic("ryuFtoaFixed32 called with prec > 9")`
`	}`
`	// Zero input.`
`	if mant == 0 {`
`		d.nd, d.dp = 0, 0`
`		return`
`	}`
`	// Renormalize to a 25-bit mantissa.`
`	e2 := exp`
`	if b := bits.Len32(mant); b < 25 {`
`		mant <<= uint(25 - b)`
`		e2 += int(b) - 25`
`	}`
`	// Choose an exponent such that rounded mant*(2^e2)*(10^q) has`
`	// at least prec decimal digits, i.e`
`	//     mant*(2^e2)*(10^q) >= 10^(prec-1)`
`	// Because mant >= 2^24, it is enough to choose:`
`	//     2^(e2+24) >= 10^(-q+prec-1)`
`	// or q = -mulByLog2Log10(e2+24) + prec - 1`
`	q := -mulByLog2Log10(e2+24) + prec - 1`

`	// Now compute mant*(2^e2)*(10^q).`
`	// Is it an exact computation?`
`	// Only small positive powers of 10 are exact (5^28 has 66 bits).`
`	exact := q <= 27 && q >= 0`

`	di, dexp2, d0 := mult64bitPow10(mant, e2, q)`
`	if dexp2 >= 0 {`
`		panic("not enough significant bits after mult64bitPow10")`
`	}`
`	// As a special case, computation might still be exact, if exponent`
`	// was negative and if it amounts to computing an exact division.`
`	// In that case, we ignore all lower bits.`
`	// Note that division by 10^11 cannot be exact as 5^11 has 26 bits.`
`	if q < 0 && q >= -10 && divisibleByPower5(uint64(mant), -q) {`
`		exact = true`
`		d0 = true`
`	}`
`	// Remove extra lower bits and keep rounding info.`
`	extra := uint(-dexp2)`
`	extraMask := uint32(1<<extra - 1)`

`	di, dfrac := di>>extra, di&extraMask`
`	roundUp := false`
`	if exact {`
`		// If we computed an exact product, d + 1/2`
`		// should round to d+1 if 'd' is odd.`
`		roundUp = dfrac > 1<<(extra-1) ||`
`			(dfrac == 1<<(extra-1) && !d0) ||`
`			(dfrac == 1<<(extra-1) && d0 && di&1 == 1)`
`	} else {`
`		// otherwise, d+1/2 always rounds up because`
`		// we truncated below.`
`		roundUp = dfrac>>(extra-1) == 1`
`	}`
`	if dfrac != 0 {`
`		d0 = false`
`	}`
`	// Proceed to the requested number of digits`
`	formatDecimal(d, uint64(di), !d0, roundUp, prec)`
`	// Adjust exponent`
`	d.dp -= q`
`}`

`// ryuFtoaFixed64 formats mant*(2^exp) with prec decimal digits.`
`func ryuFtoaFixed64(d *decimalSlice, mant uint64, exp int, prec int) {`
`	if prec > 18 {`
`		panic("ryuFtoaFixed64 called with prec > 18")`
`	}`
`	// Zero input.`
`	if mant == 0 {`
`		d.nd, d.dp = 0, 0`
`		return`
`	}`
`	// Renormalize to a 55-bit mantissa.`
`	e2 := exp`
`	if b := bits.Len64(mant); b < 55 {`
`		mant = mant << uint(55-b)`
`		e2 += int(b) - 55`
`	}`
`	// Choose an exponent such that rounded mant*(2^e2)*(10^q) has`
`	// at least prec decimal digits, i.e`
`	//     mant*(2^e2)*(10^q) >= 10^(prec-1)`
`	// Because mant >= 2^54, it is enough to choose:`
`	//     2^(e2+54) >= 10^(-q+prec-1)`
`	// or q = -mulByLog2Log10(e2+54) + prec - 1`
`	//`
`	// The minimal required exponent is -mulByLog2Log10(1025)+18 = -291`
`	// The maximal required exponent is mulByLog2Log10(1074)+18 = 342`
`	q := -mulByLog2Log10(e2+54) + prec - 1`

`	// Now compute mant*(2^e2)*(10^q).`
`	// Is it an exact computation?`
`	// Only small positive powers of 10 are exact (5^55 has 128 bits).`
`	exact := q <= 55 && q >= 0`

`	di, dexp2, d0 := mult128bitPow10(mant, e2, q)`
`	if dexp2 >= 0 {`
`		panic("not enough significant bits after mult128bitPow10")`
`	}`
`	// As a special case, computation might still be exact, if exponent`
`	// was negative and if it amounts to computing an exact division.`
`	// In that case, we ignore all lower bits.`
`	// Note that division by 10^23 cannot be exact as 5^23 has 54 bits.`
`	if q < 0 && q >= -22 && divisibleByPower5(mant, -q) {`
`		exact = true`
`		d0 = true`
`	}`
`	// Remove extra lower bits and keep rounding info.`
`	extra := uint(-dexp2)`
`	extraMask := uint64(1<<extra - 1)`

`	di, dfrac := di>>extra, di&extraMask`
`	roundUp := false`
`	if exact {`
`		// If we computed an exact product, d + 1/2`
`		// should round to d+1 if 'd' is odd.`
`		roundUp = dfrac > 1<<(extra-1) ||`
`			(dfrac == 1<<(extra-1) && !d0) ||`
`			(dfrac == 1<<(extra-1) && d0 && di&1 == 1)`
`	} else {`
`		// otherwise, d+1/2 always rounds up because`
`		// we truncated below.`
`		roundUp = dfrac>>(extra-1) == 1`
`	}`
`	if dfrac != 0 {`
`		d0 = false`
`	}`
`	// Proceed to the requested number of digits`
`	formatDecimal(d, di, !d0, roundUp, prec)`
`	// Adjust exponent`
`	d.dp -= q`
`}`

`var uint64pow10 = [...]uint64{`
`	1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,`
`	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,`
`}`

`// formatDecimal fills d with at most prec decimal digits`
`// of mantissa m. The boolean trunc indicates whether m`
`// is truncated compared to the original number being formatted.`
`func formatDecimal(d *decimalSlice, m uint64, trunc bool, roundUp bool, prec int) {`
`	max := uint64pow10[prec]`
`	trimmed := 0`
`	for m >= max {`
`		a, b := m/10, m%10`
`		m = a`
`		trimmed++`
`		if b > 5 {`
`			roundUp = true`
`		} else if b < 5 {`
`			roundUp = false`
`		} else { // b == 5`
`			// round up if there are trailing digits,`
`			// or if the new value of m is odd (round-to-even convention)`
`			roundUp = trunc || m&1 == 1`
`		}`
`		if b != 0 {`
`			trunc = true`
`		}`
`	}`
`	if roundUp {`
`		m++`
`	}`
`	if m >= max {`
`		// Happens if di was originally 99999....xx`
`		m /= 10`
`		trimmed++`
`	}`
`	// render digits (similar to formatBits)`
`	n := uint(prec)`
`	d.nd = int(prec)`
`	v := m`
`	for v >= 100 {`
`		var v1, v2 uint64`
`		if v>>32 == 0 {`
`			v1, v2 = uint64(uint32(v)/100), uint64(uint32(v)%100)`
`		} else {`
`			v1, v2 = v/100, v%100`
`		}`
`		n -= 2`
`		d.d[n+1] = smallsString[2*v2+1]`
`		d.d[n+0] = smallsString[2*v2+0]`
`		v = v1`
`	}`
`	if v > 0 {`
`		n--`
`		d.d[n] = smallsString[2*v+1]`
`	}`
`	if v >= 10 {`
`		n--`
`		d.d[n] = smallsString[2*v]`
`	}`
`	for d.d[d.nd-1] == '0' {`
`		d.nd--`
`		trimmed++`
`	}`
`	d.dp = d.nd + trimmed`
`}`

`// ryuFtoaShortest formats mant*2^exp with prec decimal digits.`
`func ryuFtoaShortest(d *decimalSlice, mant uint64, exp int, flt *floatInfo) {`
`	if mant == 0 {`
`		d.nd, d.dp = 0, 0`
`		return`
`	}`
`	// If input is an exact integer with fewer bits than the mantissa,`
`	// the previous and next integer are not admissible representations.`
`	if exp <= 0 && bits.TrailingZeros64(mant) >= -exp {`
`		mant >>= uint(-exp)`
`		ryuDigits(d, mant, mant, mant, true, false)`
`		return`
`	}`
`	ml, mc, mu, e2 := computeBounds(mant, exp, flt)`
`	if e2 == 0 {`
`		ryuDigits(d, ml, mc, mu, true, false)`
`		return`
`	}`
`	// Find 10^q *larger* than 2^-e2`
`	q := mulByLog2Log10(-e2) + 1`

`	// We are going to multiply by 10^q using 128-bit arithmetic.`
`	// The exponent is the same for all 3 numbers.`
`	var dl, dc, du uint64`
`	var dl0, dc0, du0 bool`
`	if flt == &float32info {`
`		var dl32, dc32, du32 uint32`
`		dl32, _, dl0 = mult64bitPow10(uint32(ml), e2, q)`
`		dc32, _, dc0 = mult64bitPow10(uint32(mc), e2, q)`
`		du32, e2, du0 = mult64bitPow10(uint32(mu), e2, q)`
`		dl, dc, du = uint64(dl32), uint64(dc32), uint64(du32)`
`	} else {`
`		dl, _, dl0 = mult128bitPow10(ml, e2, q)`
`		dc, _, dc0 = mult128bitPow10(mc, e2, q)`
`		du, e2, du0 = mult128bitPow10(mu, e2, q)`
`	}`
`	if e2 >= 0 {`
`		panic("not enough significant bits after mult128bitPow10")`
`	}`
`	// Is it an exact computation?`
`	if q > 55 {`
`		// Large positive powers of ten are not exact`
`		dl0, dc0, du0 = false, false, false`
`	}`
`	if q < 0 && q >= -24 {`
`		// Division by a power of ten may be exact.`
`		// (note that 5^25 is a 59-bit number so division by 5^25 is never exact).`
`		if divisibleByPower5(ml, -q) {`
`			dl0 = true`
`		}`
`		if divisibleByPower5(mc, -q) {`
`			dc0 = true`
`		}`
`		if divisibleByPower5(mu, -q) {`
`			du0 = true`
`		}`
`	}`
`	// Express the results (dl, dc, du)*2^e2 as integers.`
`	// Extra bits must be removed and rounding hints computed.`
`	extra := uint(-e2)`
`	extraMask := uint64(1<<extra - 1)`
`	// Now compute the floored, integral base 10 mantissas.`
`	dl, fracl := dl>>extra, dl&extraMask`
`	dc, fracc := dc>>extra, dc&extraMask`
`	du, fracu := du>>extra, du&extraMask`
`	// Is it allowed to use 'du' as a result?`
`	// It is always allowed when it is truncated, but also`
`	// if it is exact and the original binary mantissa is even`
`	// When disallowed, we can subtract 1.`
`	uok := !du0 || fracu > 0`
`	if du0 && fracu == 0 {`
`		uok = mant&1 == 0`
`	}`
`	if !uok {`
`		du--`
`	}`
`	// Is 'dc' the correctly rounded base 10 mantissa?`
`	// The correct rounding might be dc+1`
`	cup := false // don't round up.`
`	if dc0 {`
`		// If we computed an exact product, the half integer`
`		// should round to next (even) integer if 'dc' is odd.`
`		cup = fracc > 1<<(extra-1) ||`
`			(fracc == 1<<(extra-1) && dc&1 == 1)`
`	} else {`
`		// otherwise, the result is a lower truncation of the ideal`
`		// result.`
`		cup = fracc>>(extra-1) == 1`
`	}`
`	// Is 'dl' an allowed representation?`
`	// Only if it is an exact value, and if the original binary mantissa`
`	// was even.`
`	lok := dl0 && fracl == 0 && (mant&1 == 0)`
`	if !lok {`
`		dl++`
`	}`
`	// We need to remember whether the trimmed digits of 'dc' are zero.`
`	c0 := dc0 && fracc == 0`
`	// render digits`
`	ryuDigits(d, dl, dc, du, c0, cup)`
`	d.dp -= q`
`}`

`// mulByLog2Log10 returns math.Floor(x * log(2)/log(10)) for an integer x in`
`// the range -1600 <= x && x <= +1600.`
`//`
`// The range restriction lets us work in faster integer arithmetic instead of`
`// slower floating point arithmetic. Correctness is verified by unit tests.`
`func mulByLog2Log10(x int) int {`
`	// log(2)/log(10) ≈ 0.30102999566 ≈ 78913 / 2^18`
`	return (x * 78913) >> 18`
`}`

`// mulByLog10Log2 returns math.Floor(x * log(10)/log(2)) for an integer x in`
`// the range -500 <= x && x <= +500.`
`//`
`// The range restriction lets us work in faster integer arithmetic instead of`
`// slower floating point arithmetic. Correctness is verified by unit tests.`
`func mulByLog10Log2(x int) int {`
`	// log(10)/log(2) ≈ 3.32192809489 ≈ 108853 / 2^15`
`	return (x * 108853) >> 15`
`}`

`// computeBounds returns a floating-point vector (l, c, u)×2^e2`
`// where the mantissas are 55-bit (or 26-bit) integers, describing the interval`
`// represented by the input float64 or float32.`
`func computeBounds(mant uint64, exp int, flt *floatInfo) (lower, central, upper uint64, e2 int) {`
`	if mant != 1<<flt.mantbits || exp == flt.bias+1-int(flt.mantbits) {`
`		// regular case (or denormals)`
`		lower, central, upper = 2*mant-1, 2*mant, 2*mant+1`
`		e2 = exp - 1`
`		return`
`	} else {`
`		// border of an exponent`
`		lower, central, upper = 4*mant-1, 4*mant, 4*mant+2`
`		e2 = exp - 2`
`		return`
`	}`
`}`

`func ryuDigits(d *decimalSlice, lower, central, upper uint64,`
`	c0, cup bool) {`
`	lhi, llo := divmod1e9(lower)`
`	chi, clo := divmod1e9(central)`
`	uhi, ulo := divmod1e9(upper)`
`	if uhi == 0 {`
`		// only low digits (for denormals)`
`		ryuDigits32(d, llo, clo, ulo, c0, cup, 8)`
`	} else if lhi < uhi {`
`		// truncate 9 digits at once.`
`		if llo != 0 {`
`			lhi++`
`		}`
`		c0 = c0 && clo == 0`
`		cup = (clo > 5e8) || (clo == 5e8 && cup)`
`		ryuDigits32(d, lhi, chi, uhi, c0, cup, 8)`
`		d.dp += 9`
`	} else {`
`		d.nd = 0`
`		// emit high part`
`		n := uint(9)`
`		for v := chi; v > 0; {`
`			v1, v2 := v/10, v%10`
`			v = v1`
`			n--`
`			d.d[n] = byte(v2 + '0')`
`		}`
`		d.d = d.d[n:]`
`		d.nd = int(9 - n)`
`		// emit low part`
`		ryuDigits32(d, llo, clo, ulo,`
`			c0, cup, d.nd+8)`
`	}`
`	// trim trailing zeros`
`	for d.nd > 0 && d.d[d.nd-1] == '0' {`
`		d.nd--`
`	}`
`	// trim initial zeros`
`	for d.nd > 0 && d.d == '0' {`
`		d.nd--`
`		d.dp--`
`		d.d = d.d[1:]`
`	}`
`}`

`// ryuDigits32 emits decimal digits for a number less than 1e9.`
`func ryuDigits32(d *decimalSlice, lower, central, upper uint32,`
`	c0, cup bool, endindex int) {`
`	if upper == 0 {`
`		d.dp = endindex + 1`
`		return`
`	}`
`	trimmed := 0`
`	// Remember last trimmed digit to check for round-up.`
`	// c0 will be used to remember zeroness of following digits.`
`	cNextDigit := 0`
`	for upper > 0 {`
`		// Repeatedly compute:`
`		// l = Ceil(lower / 10^k)`
`		// c = Round(central / 10^k)`
`		// u = Floor(upper / 10^k)`
`		// and stop when c goes out of the (l, u) interval.`
`		l := (lower + 9) / 10`
`		c, cdigit := central/10, central%10`
`		u := upper / 10`
`		if l > u {`
`			// don't trim the last digit as it is forbidden to go below l`
`			// other, trim and exit now.`
`			break`
`		}`
`		// Check that we didn't cross the lower boundary.`
`		// The case where l < u but c == l-1 is essentially impossible,`
`		// but may happen if:`
`		//    lower   = ..11`
`		//    central = ..19`
`		//    upper   = ..31`
`		// and means that 'central' is very close but less than`
`		// an integer ending with many zeros, and usually`
`		// the "round-up" logic hides the problem.`
`		if l == c+1 && c < u {`
`			c++`
`			cdigit = 0`
`			cup = false`
`		}`
`		trimmed++`
`		// Remember trimmed digits of c`
`		c0 = c0 && cNextDigit == 0`
`		cNextDigit = int(cdigit)`
`		lower, central, upper = l, c, u`
`	}`
`	// should we round up?`
`	if trimmed > 0 {`
`		cup = cNextDigit > 5 ||`
`			(cNextDigit == 5 && !c0) ||`
`			(cNextDigit == 5 && c0 && central&1 == 1)`
`	}`
`	if central < upper && cup {`
`		central++`
`	}`
`	// We know where the number ends, fill directly`
`	endindex -= trimmed`
`	v := central`
`	n := endindex`
`	for n > d.nd {`
`		v1, v2 := v/100, v%100`
`		d.d[n] = smallsString[2*v2+1]`
`		d.d[n-1] = smallsString[2*v2+0]`
`		n -= 2`
`		v = v1`
`	}`
`	if n == d.nd {`
`		d.d[n] = byte(v + '0')`
`	}`
`	d.nd = endindex + 1`
`	d.dp = d.nd + trimmed`
`}`

`// mult64bitPow10 takes a floating-point input with a 25-bit`
`// mantissa and multiplies it with 10^q. The resulting mantissa`
`// is m*P >> 57 where P is a 64-bit element of the detailedPowersOfTen tables.`
`// It is typically 31 or 32-bit wide.`
`// The returned boolean is true if all trimmed bits were zero.`
`//`
`// That is:`
`//     m*2^e2 * round(10^q) = resM * 2^resE + ε`
`//     exact = ε == 0`
`func mult64bitPow10(m uint32, e2, q int) (resM uint32, resE int, exact bool) {`
`	if q == 0 {`
`		// P == 1<<63`
`		return m << 6, e2 - 6, true`
`	}`
`	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {`
`		// This never happens due to the range of float32/float64 exponent`
`		panic("mult64bitPow10: power of 10 is out of range")`
`	}`
`	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10]`
`	if q < 0 {`
`		// Inverse powers of ten must be rounded up.`
`		pow += 1`
`	}`
`	hi, lo := bits.Mul64(uint64(m), pow)`
`	e2 += mulByLog10Log2(q) - 63 + 57`
`	return uint32(hi<<7 | lo>>57), e2, lo<<7 == 0`
`}`

`// mult128bitPow10 takes a floating-point input with a 55-bit`
`// mantissa and multiplies it with 10^q. The resulting mantissa`
`// is m*P >> 119 where P is a 128-bit element of the detailedPowersOfTen tables.`
`// It is typically 63 or 64-bit wide.`
`// The returned boolean is true is all trimmed bits were zero.`
`//`
`// That is:`
`//     m*2^e2 * round(10^q) = resM * 2^resE + ε`
`//     exact = ε == 0`
`func mult128bitPow10(m uint64, e2, q int) (resM uint64, resE int, exact bool) {`
`	if q == 0 {`
`		// P == 1<<127`
`		return m << 8, e2 - 8, true`
`	}`
`	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {`
`		// This never happens due to the range of float32/float64 exponent`
`		panic("mult128bitPow10: power of 10 is out of range")`
`	}`
`	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10]`
`	if q < 0 {`
`		// Inverse powers of ten must be rounded up.`
`		pow += 1`
`	}`
`	e2 += mulByLog10Log2(q) - 127 + 119`

`	// long multiplication`
`	l1, l0 := bits.Mul64(m, pow)`
`	h1, h0 := bits.Mul64(m, pow)`
`	mid, carry := bits.Add64(l1, h0, 0)`
`	h1 += carry`
`	return h1<<9 | mid>>55, e2, mid<<9 == 0 && l0 == 0`
`}`

`func divisibleByPower5(m uint64, k int) bool {`
`	if m == 0 {`
`		return true`
`	}`
`	for i := 0; i < k; i++ {`
`		if m%5 != 0 {`
`			return false`
`		}`
`		m /= 5`
`	}`
`	return true`
`}`

`// divmod1e9 computes quotient and remainder of division by 1e9,`
`// avoiding runtime uint64 division on 32-bit platforms.`
`func divmod1e9(x uint64) (uint32, uint32) {`
`	if !host32bit {`
`		return uint32(x / 1e9), uint32(x % 1e9)`
`	}`
`	// Use the same sequence of operations as the amd64 compiler.`
`	hi, _ := bits.Mul64(x>>1, 0x89705f4136b4a598) // binary digits of 1e-9`
`	q := hi >> 28`
`	return uint32(q), uint32(x - q*1e9)`
`}`
```