AND	R1@>33, R2
	AND	$(1<<63), R1                        // AND	$-9223372036854775808, R1       // 21004192
	AND	$(1<<63-1), R1                      // AND	$9223372036854775807, R1        // 21f84092
	ORR	$(1<<63), R1                        // ORR	$-9223372036854775808, R1       // 210041b2
	ORR	$(1<<63-1), R1                      // ORR	$9223372036854775807, R1        // 21f840b2

			"638952175999932299156089414639761565182862536979208272237582" +
			"511852109168640000000000000000000000", // -99!
	},

	// overflow situations
	{math.MaxInt64 - 0, math.MaxInt64, "9223372036854775807"},
	{math.MaxInt64 - 1, math.MaxInt64, "85070591730234615838173535747377725442"},
	{math.MaxInt64 - 2, math.MaxInt64, "784637716923335094969050127519550606919189611815754530810"},

		in:       `{"0":"a","10":"c","9":"b"}`,
		ptr:      new(map[u8]string),
		out:      map[u8]string{0: "a", 9: "b", 10: "c"},
	},
	{
		CaseName: Name(""),
		in:       `{"-9223372036854775808":"min","9223372036854775807":"max"}`,
		ptr:      new(map[int64]string),
		out:      map[int64]string{math.MinInt64: "min", math.MaxInt64: "max"},
	},
	{
		CaseName: Name(""),
		in:       `{"18446744073709551615":"max"}`,

			wantResult: `{"_1":3}`,
		},
		{
			name:  "bignum-1",
			query: `SELECT id from s3object s WHERE s.id <= 9223372036854775807`,
			wantResult: `{"id":0}
{"id":1}
{"id":2}
{"id":3}`,
		},
		{
			name:  "bignum-2",
			query: `SELECT id from s3object s WHERE s.id >= -9223372036854775808`,
			wantResult: `{"id":0}
{"id":1}
{"id":2}
{"id":3}`,
		},
		{
			name:       "donatello-3",

func TestFloatInt64(t *testing.T) {
	for _, test := range []struct {
		x   string
		out int64
		acc Accuracy
	}{
		{"-Inf", math.MinInt64, Above},
		{"-1e10000", math.MinInt64, Above},
		{"-9223372036854775809", math.MinInt64, Above},
		{"-9223372036854775808.000000000000000000001", math.MinInt64, Above},
		{"-9223372036854775808", -9223372036854775808, Exact},

	N int64
}

func (r *atLeastReader) Read(p []byte) (int, error) {
	if r.N <= 0 {
		return 0, io.EOF
	}
	n, err := r.R.Read(p)
	r.N -= int64(n) // won't underflow unless len(p) >= n > 9223372036854775809
	if r.N > 0 && err == io.EOF {
		return n, io.ErrUnexpectedEOF
	}
	if r.N <= 0 && err == nil {
		return n, io.EOF
	}
	return n, err
}

		{"0.9n", decQuantity(1, -9, DecimalSI)},
		{"0.00000012345", decQuantity(124, -9, DecimalSI)},
		{"0.00000012354", decQuantity(124, -9, DecimalSI)},
		{"9Ei", Quantity{d: maxAllowed, Format: BinarySI}},
		{"9223372036854775807Ki", Quantity{d: maxAllowed, Format: BinarySI}},
		{"12E", decQuantity(12, 18, DecimalSI)},

		// We'll accept fractional binary stuff, too.
		{"100.035Ki", decQuantity(10243584, -2, BinarySI)},

	// 9007199254740993 = 1<<53+1 cannot be stored precisely in a float64
	{"9007199254740993ns", (1<<53 + 1) * Nanosecond},
	// largest duration that can be represented by int64 in nanoseconds
	{"9223372036854775807ns", (1<<63 - 1) * Nanosecond},
	{"9223372036854775.807us", (1<<63 - 1) * Nanosecond},
	{"9223372036s854ms775us807ns", (1<<63 - 1) * Nanosecond},
	{"-9223372036854775808ns", -1 << 63 * Nanosecond},