0x3f8,
      0x3f9,
      0xffa,
      0x1ff9,
      0x15,
      0xf8,
      0x7fa,
      0x3fa,
      0x3fb,
      0xf9,
      0x7fb,
      0xfa,
      0x16,
      0x17,
      0x18,
      0x0,
      0x1,
      0x2,
      0x19,
      0x1a,
      0x1b,
      0x1c,
      0x1d,
      0x1e,
      0x1f,
      0x5c,
      0xfb,
      0x7ffc,
      0x20,

  fun sourceSeesBom() {
    val body = "efbbbf68656c6c6f".decodeHex().toResponseBody()
    val source = body.source()
    assertThat(source.readByte() and 0xff).isEqualTo(0xef)
    assertThat(source.readByte() and 0xff).isEqualTo(0xbb)
    assertThat(source.readByte() and 0xff).isEqualTo(0xbf)
    assertThat(source.readUtf8()).isEqualTo("hello")
  }

  @Test
  fun bytesEmpty() {
    val body = body("")

      return strideTable[3][word & 0xFF]
          ^ strideTable[2][(word >>> 8) & 0xFF]
          ^ strideTable[1][(word >>> 16) & 0xFF]
          ^ strideTable[0][word >>> 24];
    }

    static int combine(int csum, int crc) {
      csum ^= crc;
      for (int i = 0; i < 4; i++) {
        csum = (csum >>> 8) ^ byteTable[csum & 0xFF];
      }
      return csum;
    }

          bytes.length >= 4,
          "HashCode#asInt() requires >= 4 bytes (it only has %s bytes).",
          bytes.length);
      return (bytes[0] & 0xFF)
          | ((bytes[1] & 0xFF) << 8)
          | ((bytes[2] & 0xFF) << 16)
          | ((bytes[3] & 0xFF) << 24);
    }

    @Override
    public long asLong() {
      checkState(
          bytes.length >= 8,

    val tagClass = tagAndClass and 0b1100_0000
    val constructed = (tagAndClass and 0b0010_0000) == 0b0010_0000
    val tag =
      when (val tag0 = tagAndClass and 0b0001_1111) {
        0b0001_1111 -> readVariableLengthLong()
        else -> tag0.toLong()
      }

    // Read the length.
    val length0 = source.readByte().toInt() and 0xff
    val length =
      when {

    val length = source.readMedium()
    if (length > INITIAL_MAX_FRAME_SIZE) {
      throw IOException("FRAME_SIZE_ERROR: $length")
    }
    val type = source.readByte() and 0xff
    val flags = source.readByte() and 0xff
    val streamId = source.readInt() and 0x7fffffff // Ignore reserved bit.
    if (type != TYPE_WINDOW_UPDATE && logger.isLoggable(FINE)) {
      logger.fine(frameLog(true, streamId, length, type, flags))

  require(address.size == 4)
  return Buffer()
    .writeDecimalLong((address[0] and 0xff).toLong())
    .writeByte('.'.code)
    .writeDecimalLong((address[1] and 0xff).toLong())
    .writeByte('.'.code)
    .writeDecimalLong((address[2] and 0xff).toLong())
    .writeByte('.'.code)
    .writeDecimalLong((address[3] and 0xff).toLong())
    .readUtf8()
}

/**

    assertThat(converter.convert("0")).isEqualTo(0);
    assertThat(converter.convert("-1")).isEqualTo(-1);
    assertThat(converter.convert("0xff")).isEqualTo(255);
    assertThat(converter.convert("0xFF")).isEqualTo(255);
    assertThat(converter.convert("-0xFF")).isEqualTo(-255);
    assertThat(converter.convert("#0000FF")).isEqualTo(255);
    assertThat(converter.convert("0666")).isEqualTo(438);
  }

internal fun BufferedSink.writeMedium(medium: Int) {
  writeByte(medium.ushr(16) and 0xff)
  writeByte(medium.ushr(8) and 0xff)
  writeByte(medium and 0xff)
}

@Throws(IOException::class)
internal fun BufferedSource.readMedium(): Int =
  (
    readByte() and 0xff shl 16
      or (readByte() and 0xff shl 8)
      or (readByte() and 0xff)
  )

/** Run [block] until it either throws an [IOException] or completes. */

    // Disable the timeout to read the first byte of a new frame.
    val b0: Int
    val timeoutBefore = source.timeout().timeoutNanos()
    source.timeout().clearTimeout()
    try {
      b0 = source.readByte() and 0xff
    } finally {
      source.timeout().timeout(timeoutBefore, TimeUnit.NANOSECONDS)
    }

    opcode = b0 and B0_MASK_OPCODE
    isFinalFrame = b0 and B0_FLAG_FIN != 0