val bit = 1 shl ENABLE_PUSH
    return if (bit and set != 0) values[ENABLE_PUSH] == 1 else defaultValue
  }

  fun getMaxConcurrentStreams(): Int {
    val bit = 1 shl MAX_CONCURRENT_STREAMS
    return if (bit and set != 0) values[MAX_CONCURRENT_STREAMS] else Int.MAX_VALUE
  }

  fun getMaxFrameSize(defaultValue: Int): Int {
    val bit = 1 shl MAX_FRAME_SIZE

      accumulator = (accumulator shl codeBitCount) or code.toLong()
      accumulatorBitCount += codeBitCount

      while (accumulatorBitCount >= 8) {
        accumulatorBitCount -= 8
        sink.writeByte((accumulator shr accumulatorBitCount).toInt())
      }
    }

    if (accumulatorBitCount > 0) {
      accumulator = accumulator shl (8 - accumulatorBitCount)

        val codepointDelta = (b1 and 0xF shl 14) or (b2 shl 7) or b3
        sink.writeUtf8CodePoint(codePoint - codepointDelta)
      }
      in 80..95 -> {
        // Mapped inline as codePoint delta to add
        val b2 = ranges[rangesIndex + 2].code
        val b3 = ranges[rangesIndex + 3].code

        val codepointDelta = (b1 and 0xF shl 14) or (b2 shl 7) or b3

          mappedToCodePoints = listOf((1 shl 18) - 1),
        ),
      ),
    ).isEqualTo(
      InlineDelta(
        rangeStart = 0,
        codepointDelta = InlineDelta.MAX_VALUE,
      ),
    )

    assertThat(
      inlineDeltaOrNull(
        mappingOf(
          sourceCodePoint0 = 0,
          sourceCodePoint1 = 0,
          mappedToCodePoints = listOf(1 shl 18),
        ),
      ),

    assertThat(compactTable.sections.length).isLessThan(1 shl 14)

    // Less than 65,536 bytes, because we binary search on a 14-bit index with a stride of 4 bytes.
    assertThat(compactTable.ranges.length).isLessThan((1 shl 14) * 4)

    // Less than 16,384 chars, because we index on a 14-bit index in the ranges table.
    assertThat(compactTable.mappings.length).isLessThan(1 shl 14)

    // Confirm the data strings are ASCII.

            throw ProtocolException("invalid encoding for length")
          }

          for (i in 1 until lengthBytes) {
            lengthBits = lengthBits shl 8
            lengthBits += source.readByte().toInt() and 0xff
          }

          if (lengthBits < 0) throw ProtocolException("length > Long.MAX_VALUE")

          lengthBits
        }
        else -> {

    // Read a group, one to four hex digits.
    var value = 0
    groupOffset = i
    while (i < limit) {
      val hexDigit = input[i].parseHexDigit()
      if (hexDigit == -1) break
      value = (value shl 4) + hexDigit
      i++
    }
    val groupLength = i - groupOffset
    if (groupLength == 0 || groupLength > 4) return null // Group is the wrong size.

  writeByte(medium.ushr(8) and 0xff)
  writeByte(medium and 0xff)
}

@Throws(IOException::class)
internal fun BufferedSource.readMedium(): Int {
  return (
    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. */
internal inline fun ignoreIoExceptions(block: () -> Unit) {
  try {

        while (true) {
          val b = readByte()
          if (b and 0x80 != 0) { // Equivalent to (b >= 128) since b is in [0..255].
            result += b and 0x7f shl shift
            shift += 7
          } else {
            result += b shl shift // Last byte.
            break
          }
        }
        return result
      }

      /** Reads a potentially Huffman encoded byte string. */

            if (c.isLowSurrogate() || !low.isLowSurrogate()) {
              '?'.code
            } else {
              i++
              0x010000 + (c.code and 0x03ff shl 10 or (low.code and 0x03ff))
            }
          }

          else -> c.code
        }
      i++
    }
    return result
  }

  private val Int.punycodeDigit: Int
    get() =