},
		{
			input:  "9223372036854775807", // math.MaxInt64
			output: IntOrString{Type: String, StrVal: "9223372036854775807"},
		},
		{
			input:  "-9223372036854775808", // math.MinInt64
			output: IntOrString{Type: String, StrVal: "-9223372036854775808"},
		},
		{
			input:  "9223372036854775808", // math.MaxInt64+1

	int64(183731176326946086),  // Int64N(1000000000000000000)
	int64(680987186633600239),  // Int64N(1152921504606846976)
	int64(4102454148908803108), // Int64N(9223372036854775806)
	int64(8679174511200971228), // Int64N(9223372036854775807)
	int64(0),                   // Int64N(1)
	int64(3),                   // Int64N(10)
	int64(27),                  // Int64N(32)
	int64(665831),              // Int64N(1048576)

	}
	for range maxUint /* ERROR "cannot use maxUint (untyped int constant 18446744073709551615) as int value in range clause (overflows)" */ {
	}

	for i := range maxInt {
		_ = i
	}
	for i := range maxInt /* ERROR "cannot use maxInt + 1 (untyped int constant 9223372036854775808) as int value in range clause (overflows)" */ + 1 {

	}
}

func issue11667() {
	switch 9223372036854775808 /* ERRORx `cannot use .* as int value.*\(overflows\)` */ {
	}
	switch 9223372036854775808 /* ERRORx `cannot use .* as int value.*\(overflows\)` */ {
	case 9223372036854775808:
	}
	var x int
	switch x {
	case 9223372036854775808 /* ERROR "overflows int" */ :
	}
	var y float64
	switch y {
	case 9223372036854775808:
	}
}

func issue11687() {

			Key:   apiRootAccess,
			Value: config.EnableOn,
		},
		config.KV{
			Key:   apiSyncEvents,
			Value: config.EnableOff,
		},
		config.KV{
			Key:   apiObjectMaxVersions,
			Value: "9223372036854775807",
		},
	}
)

// Config storage class configuration
type Config struct {
	RequestsMax                 int           `json:"requests_max"`

	unstructuredObj := gottenNoxuInstance.(*unstructured.Unstructured).Object
	num := unstructuredObj["num"].(map[string]interface{})
	num1 := num["num1"].(int64)
	num2 := num["num2"].(int64)
	if num1 != 9223372036854775807 || num2 != 1000000 {
		t.Errorf("Expected %v, got %v, %v", `9223372036854775807, 1000000`, num1, num2)
	}
}

func TestPatch(t *testing.T) {

		istr string
		f    float64
		acc  Accuracy
	}{
		{"-1000000000000000000000000000000000000000000000000000000", -1000000000000000078291540404596243842305360299886116864.000000, Below},
		{"-9223372036854775809", math.MinInt64, Above},
		{"-9223372036854775808", -9223372036854775808, Exact}, // -2^63
		{"-9223372036854775807", -9223372036854775807, Below},
		{"-18014398509481985", -18014398509481984.000000, Above},

		},
		// too big of the integer
		{
			filenames:    []string{"92233720368547758089223372036854775808.log.rotated"},
			restartCount: 0,
		},
		// mix of log files
		{
			filenames:    []string{"9223372036854775808.log.rotated", "23.log", "23a.log", "1aaa.log.rotated", "2.log", "3.log.rotated"},
			restartCount: 24,
		},
		// prefixed
		{
			filenames:    []string{"rotated.23.log"},
			restartCount: 0,
		},
		{

		// and the normal JMP generated at the end of the block.
		d += e
	}
	return d, e
}

func NoFix64B(divd int64) (int64, int64) {
	var d int64
	var e int64
	var divr int64 = -1
	if divd > -9223372036854775808 {
		d = divd / divr // amd64:-"JMP"
		e = divd % divr // amd64:-"JMP"
		d += e
	}
	return d, e
}

func NoFix32A(divr int32) (int32, int32) {
	var d int32 = 42
	var e int32 = 84

          assertEquals(expected, BigIntegerMath.divide(p, q, mode));
        }
      }
    }
  }

  private static final BigInteger BAD_FOR_ANDROID_P = new BigInteger("-9223372036854775808");
  private static final BigInteger BAD_FOR_ANDROID_Q = new BigInteger("-1");

  @GwtIncompatible // TODO
  @AndroidIncompatible // slow
  public void testDivNonZeroExact() {