CMPU	R4, R5                 // b9210045
	CMPU	R6, $4294967295        // c26effffffff
	CMPW	R7, R8                 // 1978
	CMPW	R9, $-32768            // a79e8000
	CMPW	R9, $-32769            // c29dffff7fff
	CMPW	R9, $-2147483648       // c29d80000000
	CMPWU	R1, R2                 // 1512
	CMPWU	R3, $4294967295        // c23fffffffff

	TMHH	R1, $65535             // a712ffff

type uint8 uint8

// uint16 is the set of all unsigned 16-bit integers.
// Range: 0 through 65535.
type uint16 uint16

// uint32 is the set of all unsigned 32-bit integers.
// Range: 0 through 4294967295.
type uint32 uint32

// uint64 is the set of all unsigned 64-bit integers.
// Range: 0 through 18446744073709551615.
type uint64 uint64

// int8 is the set of all signed 8-bit integers.

	AND	$0xffffff55, R5     // AND $4294967125, R5       // aab0e0e30b5005e0
	AND.S	$0xffffffab, R2, R3 // AND.S $4294967211, R2, R3 // 54b0e0e30b3012e0
	AND.S	$0xffffff54, R5     // AND.S $4294967124, R5     // abb0e0e30b5015e0
	ORR	$0xffffffaa, R2, R3 // ORR $4294967210, R2, R3   // 55b0e0e30b3082e1
	ORR	$0xffffff55, R5     // ORR $4294967125, R5       // aab0e0e30b5085e1

	// Converted to load and shift(s)
	MOV	$0xffffffff, X5		// MOV	$4294967295, X5			// 9302f0ff93d20202
	MOV	$0x80000001, X5		// MOV	$2147483649, X5			// b70200809b8212009392020293d20202 or b70200809b821200bb820208
	MOV	$0x100000000, X5	// MOV	$4294967296, X5			// 9302100093920202
	MOV	$0xfffffffffffda, X5	// MOV	$4503599627370458, X5		// 9302d0fe9392d20093d2c200

</p>

<pre class="grammar">
uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)

    fi
  fi
}

# hash string like Java String::hashCode
hash_string() {
  str="${1:-}" h=0
  while [ -n "$str" ]; do
    char="${str%"${str#?}"}"
    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
    str="${str#?}"
  done
  printf %x\\n $h
}

verbose() { :; }
[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }

die() {
  printf %s\\n "$1" >&2
  exit 1
}

        void testDecode64BitValues() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[24];
            // alloc (8 bytes) - 0x0000000100000000 (4294967296)
            buffer[4] = 0x01;
            // free (8 bytes) - 0x0000000080000000 (2147483648)
            buffer[12] = (byte) 0x80;
            // sectPerAlloc (4 bytes) - 8
            buffer[16] = 0x08;

	SLLIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
	SRLIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
	SRAIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
	SD	X5, 4294967296(X6)		// ERROR "constant 4294967296 too large"
	FNES	F1, (X5)			// ERROR "needs an integer register output"

	// Memory Ordering Instructions
	FENCE		X1, R				// ERROR "invalid FENCE predecessor operand"

    for (long a : ALL_LONG_CANDIDATES) {
      for (long b : ALL_LONG_CANDIDATES) {
        if (isAndroid && a == -4294967296L && b == 2147483648L) {
          /*
           * Bug in older versions of Android we test against, since fixed: -9223372036854775808L /
           * -4294967296L = -9223372036854775808L!
           *
           * To be clear, this bug affects not the test's computation of the expected result but the

    assertThat(expected)
        .hasMessageThat()
        .isEqualTo(
            "BigInteger cannot be converted to InetAddress because it has more than 4 bytes:"
                + " 4294967297");
  }

  public void testFromIpv6BigIntegerInputTooLarge() {
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () ->