flags: Int,
    streamId: Int,
  ) {
    val increment: Long
    try {
      if (length != 4) throw IOException("TYPE_WINDOW_UPDATE length !=4: $length")
      increment = source.readInt() and 0x7fffffffL
      if (increment == 0L) throw IOException("windowSizeIncrement was 0")
    } catch (e: Exception) {
      logger.fine(frameLog(true, streamId, length, TYPE_WINDOW_UPDATE, flags))
      throw e
    }

          .that(UnsignedInteger.fromIntBits(value).intValue())
          .isEqualTo(value);
    }
  }

  public void testFromIntBitsLongValue() {
    for (int value : TEST_INTS) {
      long expected = value & 0xffffffffL;
      assertWithMessage(UnsignedInts.toString(value))
          .that(UnsignedInteger.fromIntBits(value).longValue())
          .isEqualTo(expected);
    }
  }

  public void testValueOfLong() {

    public boolean containsKey(final Object key) {
        final Entry<K, V>[] tbl = mapTable;
        if (key != null) {
            final int hashCode = key.hashCode();
            final int index = (hashCode & 0x7FFFFFFF) % tbl.length;
            for (Entry<K, V> e = tbl[index]; e != null; e = e.next) {
                if (e.hashCode == hashCode && key.equals(e.key)) {
                    return true;
                }
            }

      int count = 0;
      // originally was 2 * Math.log(...), making it try more times to avoid flakiness issues
      int maxCount = (int) (4 * Math.log(2 * keyBits * hashBits) + 1);
      while (same != 0xffffffff || diff != 0xffffffff) {
        int key1 = rand.nextInt();
        // flip input bit for key2
        int key2 = key1 ^ (1 << i);
        // get hashes
        int hash1 = function.hashInt(key1).asInt();

      this.h1 = seed;
      this.length = 0;
      isDone = false;
    }

    private void update(int nBytes, long update) {
      // 1 <= nBytes <= 4
      buffer |= (update & 0xFFFFFFFFL) << shift;
      shift += nBytes * 8;
      length += nBytes;

      if (shift >= 32) {
        h1 = mixH1(h1, mixK1((int) buffer));
        buffer >>>= 32;
        shift -= 32;
      }
    }

      }

      @Override
      long mulMod(long a, long b, long m) {
        long aHi = a >>> 32; // < 2^31
        long bHi = b >>> 32; // < 2^31
        long aLo = a & 0xFFFFFFFFL; // < 2^32
        long bLo = b & 0xFFFFFFFFL; // < 2^32

        /*
         * a * b == aHi * bHi * 2^64 + (aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo.
         *       == (aHi * bHi * 2^32 + aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo

	SRLI	$1, F1, X5			// ERROR "expected integer register in rs1 position but got non-integer register F1"

	WORD	$-1				// ERROR "must be in range [0x0, 0xffffffff]"
	WORD	$0x100000000			// ERROR "must be in range [0x0, 0xffffffff]"

	//
	// "C" Extension for Compressed Instructions, Version 2.0
	//
	CLWSP	20(X5), X10				// ERROR "rs2 must be SP/X2"
	CLWSP	20(SP), X0				// ERROR "cannot use register X0"

    coercedHash |= 0xe0000000;

    // Fixup to avoid some "illegal" values. Currently the only potential
    // illegal value is 255.255.255.255.
    if (coercedHash == 0xffffffff) {
      coercedHash = 0xfffffffe;
    }

    return getInet4Address(Ints.toByteArray(coercedHash));
  }

  /**
   * Returns an integer representing an IPv4 address regardless of whether the supplied argument is

	TST $0xfffffff0, LR                        // TST $4294967280, R30          // df6f7cf2
	TSTW R10@>21, R2                           // 5f54ca6a
	TST R17<<11, R24                           // 1f2f11ea
	ANDSW $0x80000007, R9, ZR                  // ANDSW   $2147483655, R9, ZR   // 3f0d0172
	ANDS $0xfffffff0, LR, ZR                   // ANDS    $4294967280, R30, ZR  // df6f7cf2

	MOV	$0x7ffff000, X5		// MOV	$2147479552, X5			// b7f2ff7f
	MOV	$-0x7ffff000, X5	// MOV	$-2147479552, X5		// b7120080
	MOV	$0x7fffffff, X5		// MOV	$2147483647, X5			// b70200809b82f2ff
	MOV	$-0x7fffffff, X5	// MOV	$-2147483647, X5		// b70200809b821200

	// Converted to load and shift(s)
	MOV	$0xffffffff, X5		// MOV	$4294967295, X5			// 9302f0ff93d20202