// appendCodePoint(). The Punycode algorithm processes code points in increasing code-point
    // order, not in increasing index order.
    val codePoints = mutableListOf<Int>()

    // consume all code points before the last delimiter (if there is one)
    //  and copy them to output, fail on any non-basic code point
    val lastDelimiter = string.lastIndexOf('-', limit)
    if (lastDelimiter >= pos) {

A wildcard rule was added that wildcards the first level! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
  }

  companion object {
    private const val NEWLINE = '\n'.code
    private const val WILDCARD_CHAR = "*"
    private val EXCEPTION_RULE_MARKER: ByteString = "!".encodeUtf8()
  }
}

suspend fun main() {
  PublicSuffixListGenerator().import()

kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "org-jetbrains-coroutines" }
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "org-jetbrains-coroutines" }
kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinx-serialization" }

  testImplementation(libs.assertk)
  testImplementation(projects.okhttpTls)
  testImplementation(libs.androidx.test.runner)
  testImplementation(libs.robolectric)
  testImplementation(libs.androidx.espresso.core)
  testImplementation(libs.squareup.okio.fakefilesystem)

  androidTestImplementation(projects.okhttpTls)
  androidTestImplementation(libs.assertk)
  androidTestImplementation(projects.mockwebserver3Junit4)

    val call = client.newCall(networkRequest)

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNull()
    }

    val cachedCall = client.newCall(request)

    cachedCall.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNotNull()
    }
  }

  private fun assumeNetwork() {

      assertEquals(200, response.code)
      assertEquals("h3", response.negotiatedProtocol)
      assertTrue(response.content.contains("Disallow"))
    } catch (ee: ExecutionException) {
      throw ee.cause?.cause ?: ee.cause!!
    }
  }

  data class Response(
    val code: Int,
    val negotiatedProtocol: String,
    val content: String,
  )

    System.out.println("MESSAGE: " + bytes.hex());
  }

  @Override public void onClosing(WebSocket webSocket, int code, String reason) {
    webSocket.close(1000, null);
    System.out.println("CLOSE: " + code + " " + reason);
  }

  @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) {
    t.printStackTrace();
  }

/**
 * An IDNA mapping table optimized for small code and data size.
 *
 * Code Points in Sections
 * =======================
 *
 * The full range of code points is 0..0x10fffe. We can represent any of these code points with 21
 * bits.
 *
 * We split each code point into a 14-bit prefix and a 7-bit suffix. All code points with the same
 * prefix are called a 'section'. There are 128 code points per section.
 *

fun Response.Builder.commonRequest(request: Request) =
  apply {
    this.request = request
  }

fun Response.Builder.commonProtocol(protocol: Protocol) =
  apply {
    this.protocol = protocol
  }

fun Response.Builder.commonCode(code: Int) =
  apply {
    this.code = code
  }

    private val response =
      Response.Builder()
        .request(Request("https://example.com/".toHttpUrl()))
        .protocol(Protocol.HTTP_1_1)
        .message("OK")
        .code(200)
        .body(
          object : ResponseBody() {
            override fun contentType() = null

            override fun contentLength() = -1L

            override fun source() =