internal const val OPCODE_CONTROL_PING = 0x9
  internal const val OPCODE_CONTROL_PONG = 0xa

  /**
   * Maximum length of frame payload. Larger payloads, if supported by the frame type, can use the
   * special values [PAYLOAD_SHORT] or [PAYLOAD_LONG].
   */
  internal const val PAYLOAD_BYTE_MAX = 125L

  /** Maximum length of close message in bytes. */
  internal const val CLOSE_MESSAGE_MAX = PAYLOAD_BYTE_MAX - 2

  /**

APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit

# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum

warn () {
    echo "$*"
} >&2

die () {
    echo
    echo "$*"
    echo
    exit 1
} >&2

# OS specific support (must be 'true' or 'false').

 *
 * Each dispatcher uses an [ExecutorService] to run calls internally. If you supply your own
 * executor, it should be able to run [the configured maximum][maxRequests] number of calls
 * concurrently.
 */
class Dispatcher() {
  internal val lock: ReentrantLock = ReentrantLock()

  /**
   * The maximum number of requests to execute concurrently. Above this requests queue in memory,
   * waiting for the running calls to complete.
   *

    if (Log.isLoggable(tag, logLevel)) {
      var logMessage = message
      if (t != null) logMessage = logMessage + '\n'.toString() + Log.getStackTraceString(t)

      // Split by line, then ensure each line can fit into Log's maximum length.
      var i = 0
      val length = logMessage.length
      while (i < length) {
        var newline = logMessage.indexOf('\n', i)
        newline = if (newline != -1) newline else length
        do {

    private val ONLY_HTTP1 = listOf(Protocol.HTTP_1_1)

    /**
     * The maximum number of bytes to enqueue. Rather than enqueueing beyond this limit we tear down
     * the web socket! It's possible that we're writing faster than the peer can read.
     */
    private const val MAX_QUEUE_SIZE = 16L * 1024 * 1024 // 16 MiB.

    /**
     * The maximum amount of time after the client calls [close] to wait for a graceful shutdown. If

     * Sets the close timeout for web socket connections. A value of 0 means no timeout, otherwise
     * values must be between 1 and [Integer.MAX_VALUE] when converted to milliseconds.
     *
     * The close timeout is the maximum amount of time after the client calls [WebSocket.close] to
     * wait for a graceful shutdown. If the server doesn't respond the web socket will be canceled.
     * The default value is 60 seconds.
     */

    }

  fun assertSentRequestAtMillis(
    minimum: Long,
    maximum: Long,
  ) = apply {
    assertDateInRange(minimum, response!!.sentRequestAtMillis, maximum)
  }

  fun assertReceivedResponseAtMillis(
    minimum: Long,
    maximum: Long,
  ) = apply {
    assertDateInRange(minimum, response!!.receivedResponseAtMillis, maximum)
  }

  private fun assertDateInRange(
    minimum: Long,

 * @param maxSize the maximum number of bytes this cache should use to store.
 */
class DiskLruCache(
  fileSystem: FileSystem,
  /** Returns the directory where this cache stores its data. */
  val directory: Path,
  private val appVersion: Int,
  internal val valueCount: Int,
  /** Returns the maximum number of bytes that this cache should use to store its data. */
  maxSize: Long,

import okhttp3.internal.okHttpName
import okhttp3.internal.platform.Platform
import okio.IOException

class RealConnectionPool(
  private val taskRunner: TaskRunner,
  /**
   * The maximum number of idle connections across all addresses.
   * Connections needed to satisfy a [ConnectionPool.AddressPolicy] are not considered idle.
   */
  private val maxIdleConnections: Int,
  keepAliveDuration: Long,

   * synchronization to safely receive incoming data frames, it is not intended for use by multiple
   * readers.
   */
  inner class FramingSource internal constructor(
    /** Maximum number of bytes to buffer before reporting a flow control error. */
    private val maxByteCount: Long,
    /**
     * True if either side has cleanly shut down this stream. We will receive no more bytes beyond