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
    }

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

    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

	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

 * primitive utilities</a>.
 *
 * @author Louis Wasserman
 * @since 11.0
 */
@GwtCompatible
public final class UnsignedInts {
  static final long INT_MASK = 0xffffffffL;

  private UnsignedInts() {}

  static int flip(int value) {
    return value ^ Integer.MIN_VALUE;
  }

  /**

        InetAddresses.coerceToInteger(
            InetAddresses.getCoercedIPv4Address(InetAddresses.forString("2001:4860::1")));
    assertThat(coercedInt).isAtLeast(0xe0000000);
    assertThat(coercedInt).isAtMost(0xfffffffe);
  }

  public void testCoerceToInteger() {
    assertThat(InetAddresses.coerceToInteger(InetAddresses.forString("127.0.0.1")))
        .isEqualTo(0x7f000001);
  }

  public void testFromInteger() {

sign extended to implicit infinite precision; otherwise it is zero extended.
It is then truncated to fit in the result type's size.
For example, if <code>v := uint16(0x10F0)</code>, then <code>uint32(int8(v)) == 0xFFFFFFF0</code>.
The conversion always yields a valid value; there is no indication of overflow.
</li>
<li>
When converting a <a href="#Numeric_types">floating-point number</a> to an integer, the fraction is discarded