"1/3",
}

// isFinite reports whether f represents a finite rational value.
// It is equivalent to !math.IsNan(f) && !math.IsInf(f, 0).
func isFinite(f float64) bool {
	return math.Abs(f) <= math.MaxFloat64
}

func TestFloat32SpecialCases(t *testing.T) {
	for _, input := range float64inputs {
		if strings.HasPrefix(input, "long:") {
			if !*long {
				continue
			}
			input = input[len("long:"):]

		// Iterate through the various n-choose-k NUMA node combinations,
		// looking for the combination of NUMA nodes that can best have CPUs
		// distributed across them.
		var bestBalance float64 = math.MaxFloat64
		var bestRemainder []int = nil
		var bestCombo []int = nil
		acc.iterateCombinations(numas, k, func(combo []int) LoopControl {
			// If we've already found a combo with a balance of 0 in a

pkg math (windows-amd64), const MaxInt = 9223372036854775807
pkg math (windows-amd64), const MaxUint = 18446744073709551615
pkg math (windows-amd64), const MinInt = -9223372036854775808

		{"-0x0p-10", -zero_},
		{"0xff", 255},
		{"0X.8p1", 1},
		{"-0X0.00008p16", -0.5},
		{"-0X0.00008P+16", -0.5},
		{"0x0.0000000000001p-1022", math.SmallestNonzeroFloat64},
		{"0x1.fffffffffffffp1023", math.MaxFloat64},

		// underscores
		{"0_0", 0},
		{"1_000.", 1000},
		{"1_2_3.4_5_6", 123.456},
		{"1.0e0_0", 1},
		{"1p+1_0", 1024},
		{"0b_1000", 0x8},
		{"0b_1011_1101", 0xbd},

			want:          float64(math.SmallestNonzeroFloat64),
			assertOnError: assertNilError,
		},
		{
			name:          "max float64 value",
			in:            hex("fb7fefffffffffffff"),
			want:          float64(math.MaxFloat64),
			assertOnError: assertNilError,
		},
		{
			name:          "max float32 value as double precision",
			in:            hex("fb47efffffe0000000"),
			want:          float64(math.MaxFloat32),

pkg crypto/tls, type ConnectionState struct, TLSUnique //deprecated
pkg debug/elf, const R_PPC64_SECTOFF_LO_DS = 61
pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)

	v := float64FromBits(u)
	av := v
	if av < 0 {
		av = -av
	}
	// +Inf is OK in both 32- and 64-bit floats. Underflow is always OK.
	if math.MaxFloat32 < av && av <= math.MaxFloat64 {
		error_(ovfl)
	}
	return v
}

// decFloat32 decodes an unsigned integer, treats it as a 32-bit floating-point
// number, and stores it in value.

// represented by a float64 (|x| < [math.SmallestNonzeroFloat64]), the result
// is (0, [Below]) or (-0, [Above]), respectively, depending on the sign of x.
// If x is too large to be represented by a float64 (|x| > [math.MaxFloat64]),
// the result is (+Inf, [Above]) or (-Inf, [Below]), depending on the sign of x.
func (x *Float) Float64() (float64, Accuracy) {
	if debugFloat {
		x.validate()
	}

	switch x.form {
	case finite: