//
//	Cbrt(±0) = ±0
//	Cbrt(±Inf) = ±Inf
//	Cbrt(NaN) = NaN
func Cbrt(x float64) float64 {
	if haveArchCbrt {
		return archCbrt(x)
	}
	return cbrt(x)
}

func cbrt(x float64) float64 {
	const (
		B1             = 715094163                   // (682-0.03306235651)*2**20
		B2             = 696219795                   // (664-0.03306235651)*2**20
		C              = 5.42857142857142815906e-01  // 19/35     = 0x3FE15F15F15F15F1

00000070  ff f6 84 af c4 cf c2 ed  90 99 5f 58 cb 3b 74 14  |.........._X.;t.|
00000080  03 03 00 01 01 17 03 03  00 17 4f 52 70 18 74 9c  |..........ORp.t.|
00000090  40 4e b0 5a 7a bc aa b0  b9 22 70 b1 90 9c 04 ef  |@N.Zz...."p.....|
000000a0  e7 17 03 03 02 6d a8 7e  5a 4a 5f 3d 97 f2 74 93  |.....m.~ZJ_=..t.|
000000b0  ce 75 f5 be 0f 2e c4 58  d6 91 4d fb 9f 80 56 3c  |.u.....X..M...V<|

		payload, err := os.ReadFile(fn)
		if err != nil {
			t.Fatalf("failed to read executable '%s': %v", fn, err)
		}
		return payload
	}

	b1 := readBytes(scenarios[0].libpath)
	b2 := readBytes(scenarios[1].libpath)
	if !bytes.Equal(b1, b2) {
		t.Fatalf("concurrent and serial builds produced different output")
	}

00000210  38 a3 9c 15 3f 0e cc 63  43 8f b0 c1 14 97 ee 85  |8...?..cC.......|
00000220  30 08 b1 95 0c 7f 5b 95  4d 4f 18 26 d8 45 cb b4  |0.....[.MO.&.E..|
00000230  b7 1b f5 a5 d5 e5 21 da  53 88 57 09 ed 30 fe d1  |......!.S.W..0..|
00000240  ac ee c7 80 ee a9 96 31  92 4c a1 e2 2c a8 f5 b1  |.......1.L..,...|
00000250  d9 3c bd c8 e6 1b ba 7c  91 d6 6c d4 ae 0a 15 50  |.<.....|..l....P|

00000240  df d3 20 64 38 92 24 3a  00 bc cf 9c 7d b7 40 20  |.. d8.$:....}.@ |
00000250  01 5f aa d3 16 61 09 a2  76 fd 13 c3 cc e1 0c 5c  |._...a..v......\|
00000260  ee b1 87 82 f1 6c 04 ed  73 bb b3 43 77 8d 0c 1c  |.....l..s..Cw...|
00000270  f1 0f a1 d8 40 83 61 c9  4c 72 2b 9d ae db 46 06  |******@****.***+...F.|
00000280  06 4d f4 c1 b3 3e c0 d1  bd 42 d4 db fe 3d 13 60  |.M...>...B...=.`|

// Copyright 2017 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 p

var (
	i0 uint8
	b0 byte

	i1 *uint8
	b1 *byte

	i2 **uint8
	b2 **byte

	i3 ***uint8
	b3 ***byte

	i4 ****uint8
	b4 ****byte

	i5 *****uint8
	b5 *****byte

	i6 ******uint8
	b6 ******byte

	i7 *******uint8

00000070  2a 13 56 26 47 33 7d 4f  ab 5a fc 9c 9e 8d f4 75  |*.V&G3}O.Z.....u|
00000080  d0 64 16 ba f2 0d 04 ca  5d 94 6b da a8 09 b1 29  |.d......].k....)|
00000090  70 a9 37 1e ac 94 e3 81  60 c3 19 f3 a9 99 6a 11  |p.7.....`.....j.|
000000a0  b1 e7 23 45 8a f5 42 f5  50 76 9f 1e 9e a8 e7 75  |..#E..B.Pv.....u|
000000b0  4a 18 84 80 da 10 ed 83  9a 14 a9 a1 90 54 8e 8b  |J............T..|

	r1 := int32(r)
	g1 := int32(g)
	b1 := int32(b)

	// yy is in range [0,0xff].
	//
	// Note that 19595 + 38470 + 7471 equals 65536.
	yy := (19595*r1 + 38470*g1 + 7471*b1 + 1<<15) >> 16

	// The bit twiddling below is equivalent to
	//
	// cb := (-11056*r1 - 21712*g1 + 32768*b1 + 257<<15) >> 16
	// if cb < 0 {
	//     cb = 0
	// } else if cb > 0xff {

	d := int(u0) - int(u1)
	if d < 0 {
		return -d
	}
	return d
}

func withinTolerance(c0, c1 color.Color, tolerance int) bool {
	r0, g0, b0, a0 := c0.RGBA()
	r1, g1, b1, a1 := c1.RGBA()
	r := delta(r0, r1)
	g := delta(g0, g1)
	b := delta(b0, b1)
	a := delta(a0, a1)
	return r <= tolerance && g <= tolerance && b <= tolerance && a <= tolerance
}

func TestDecode(t *testing.T) {
	rgba := func(c color.Color) string {

00000020  41 74 2e b1 65 cd c6 93  06 71 f0 25 20 21 c5 1b  |At..e....q.% !..|
00000030  d2 ea eb e4 06 15 03 02  00 30 00 00 00 00 00 00  |.........0......|
00000040  00 00 00 00 00 00 00 00  00 00 1e a9 c0 dc d8 23  |...............#|
00000050  f2 08 b0 c5 b2 2e 53 9b  23 50 8a 02 c6 41 9a 36  |......S.#P...A.6|