pkg syscall (freebsd-arm64), const PTRACE_KILL ideal-int
pkg syscall (freebsd-arm64), const PTRACE_TRACEME = 0
pkg syscall (freebsd-arm64), const PTRACE_TRACEME ideal-int
pkg syscall (freebsd-arm64), const RLIM_INFINITY = 9223372036854775807
pkg syscall (freebsd-arm64), const RLIM_INFINITY ideal-int
pkg syscall (freebsd-arm64), const RLIMIT_AS = 10
pkg syscall (freebsd-arm64), const RLIMIT_AS ideal-int
pkg syscall (freebsd-arm64), const RLIMIT_CORE = 4

pkg syscall (darwin-arm64), const RLIMIT_NOFILE ideal-int
pkg syscall (darwin-arm64), const RLIMIT_STACK = 3
pkg syscall (darwin-arm64), const RLIMIT_STACK ideal-int
pkg syscall (darwin-arm64), const RLIM_INFINITY = 9223372036854775807
pkg syscall (darwin-arm64), const RLIM_INFINITY ideal-int
pkg syscall (darwin-arm64), const RTAX_AUTHOR = 6
pkg syscall (darwin-arm64), const RTAX_AUTHOR ideal-int
pkg syscall (darwin-arm64), const RTAX_BRD = 7

int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE 754 32-bit floating-point numbers
float64     the set of all IEEE 754 64-bit floating-point numbers

	{in: "1e+14e-5"},
	{in: "1e4.5"},
	{in: "r"},
	{in: "a/b"},
	{in: "a.b"},
	{in: "1/0"},
	{in: "4/3/2"}, // issue 17001
	{in: "4/3/"},
	{in: "4/3."},
	{in: "4/"},
	{in: "13e-9223372036854775808"}, // CVE-2022-23772

	// valid
	{"0", "0", true},
	{"-0", "0", true},
	{"1", "1", true},
	{"-1", "-1", true},
	{"1.", "1", true},
	{"1e0", "1", true},
	{"1.e1", "10", true},

// TODO means they cannot be handled by current assembler.

#include "../../../../../runtime/textflag.h"

TEXT asmtest(SB),DUPOK|NOSPLIT,$-8

	AND $(1<<63), R1                           // AND $-9223372036854775808, R1     // 21004192
	ADCW ZR, R8, R10                           // 0a011f1a
	ADC R0, R2, R12                            // 4c00009a
	ADCSW R9, R21, R6                          // a602093a

    assertThat(Adapters.INTEGER_AS_LONG.toDer(Long.MIN_VALUE)).isEqualTo(bytes)
  }

  @Test fun `bigger than max long`() {
    val bytes = "0209008000000000000001".decodeHex()
    val bigInteger = BigInteger("9223372036854775809")
    assertThat(Adapters.INTEGER_AS_BIG_INTEGER.fromDer(bytes)).isEqualTo(bigInteger)
    assertThat(Adapters.INTEGER_AS_BIG_INTEGER.toDer(bigInteger)).isEqualTo(bytes)
  }

  @Test fun `utf8 string`() {

		// 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

		},
		// 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,
		},
		{

          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() {

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},