}

  private suspend fun updateLocalFile() =
    withContext(Dispatchers.IO) {
      client.newCall(request).executeAsync().use { response ->
        fileSystem.sink(publicSuffixListDotDat).buffer().use { sink ->
          sink.writeAll(response.body.source())
        }
      }
    }

  private suspend fun readImportResults(): ImportResults =
    withContext(Dispatchers.IO) {

  private var outputByteCount = 0L

  fun wrapInput(source: Source): Source {
    return object : ForwardingSource(source) {
      override fun read(
        sink: Buffer,
        byteCount: Long,
      ): Long {
        val result = super.read(sink, byteCount)
        if (result == -1L) return result
        inputByteCount += result
        return result
      }
    }
  }

      Http1ExchangeCodec(client, this, source, sink)
    }
  }

  @Throws(SocketException::class)
  internal fun newWebSocketStreams(exchange: Exchange): RealWebSocket.Streams {
    val socket = this.socket!!
    val source = this.source!!
    val sink = this.sink!!

    socket.soTimeout = 0
    noNewExchanges()
    return object : RealWebSocket.Streams(true, source, sink) {
      override fun close() {

   */
  private inner class ChunkedSink : Sink {
    private val timeout = ForwardingTimeout(sink.timeout())
    private var closed: Boolean = false

    override fun timeout(): Timeout = timeout

    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {
      check(!closed) { "closed" }
      if (byteCount == 0L) return

        byteCount += contentLength
      } else {
        body.writeTo(sink)
      }

      sink.write(CRLF)
    }

    sink!!.write(DASHDASH)
    sink.write(boundaryByteString)
    sink.write(DASHDASH)
    sink.write(CRLF)

    if (countBytes) {
      byteCount += byteCountBuffer!!.size
      byteCountBuffer.clear()
    }

    return byteCount
  }

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

    if (accumulatorBitCount > 0) {
      accumulator = accumulator shl (8 - accumulatorBitCount)
      accumulator = accumulator or (0xffL ushr accumulatorBitCount)
      sink.writeByte(accumulator.toInt())
    }
  }

  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {
    log("delete($path)")

    super.delete(path, mustExist)
  }

  override fun sink(
    path: Path,
    mustCreate: Boolean,
  ): Sink {
    log("sink($path)")

    return super.sink(path, mustCreate)
  }

  override fun source(file: Path): Source {
    log("source($file)")

    return super.source(file)
  }

  /**
   * Returns the number of bytes that will be written to sink in a call to [writeTo],
   * or -1 if that count is unknown.
   */
  @Throws(IOException::class)
  open fun contentLength(): Long = commonContentLength()

  /** Writes the content of this request to [sink]. */
  @Throws(IOException::class)
  abstract fun writeTo(sink: BufferedSink)

  /**

   *
   * @param sink the output byte array
   * @param offset the offset into the array at which to start writing
   * @param value the value to write
   */
  static void store64(byte[] sink, int offset, long value) {
    // We don't want to assert in production code.
    assert offset >= 0 && offset + 8 <= sink.length;
    // Delegates to the fast (unsafe)version or the fallback.

    fun writeTo(editor: DiskLruCache.Editor) {
      editor.newSink(ENTRY_METADATA).buffer().use { sink ->
        sink.writeUtf8(url.toString()).writeByte('\n'.code)
        sink.writeUtf8(requestMethod).writeByte('\n'.code)
        sink.writeDecimalLong(varyHeaders.size.toLong()).writeByte('\n'.code)
        for (i in 0 until varyHeaders.size) {
          sink.writeUtf8(varyHeaders.name(i))
            .writeUtf8(": ")