@solibo/home-api 1.1.9 → 1.1.10

package/ktor-ktor-io.mjs

@@ -0,0 +1,3536 @@
+import {
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  toString30pk9tzaqopn as toString,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  createFailure8paxfkfa5dc7 as createFailure,
+  Result3t1vadv16kmzk as Result,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  toString1h6jjoch8cjt8 as toString_0,
+  newThrowablezl37abp36p5f as newThrowable,
+  stackTraceToString2670q6lbhdojj as stackTraceToString,
+  VOID3gxj6tk5isa35 as VOID,
+  isInterface3d6p8outrmvmk as isInterface,
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  fromInt2ii0rejb1w62w as fromInt,
+  numberToLong2pakxeg38estk as numberToLong,
+  add2suhfggl4zvkk as add,
+  intercepted2ogpsikxxj4u0 as intercepted,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  returnIfSuspended1blqheeew1z6h as returnIfSuspended,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  convertToInty04h231mmjoh as convertToInt,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  IllegalStateException_init_$Init$2vym5snx4gpwu as IllegalStateException_init_$Init$,
+  captureStack1fzi4aczwc4hg as captureStack,
+  replace3le3ie7l9k8aq as replace,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  get_ONEazvfdh9ju3d4 as get_ONE,
+  toString1pkumu07cwy4m as toString_1,
+  IllegalArgumentException_init_$Create$1j1aj36nbo0wg as IllegalArgumentException_init_$Create$,
+  subtract2orl8z9upxd9l as subtract,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+  EmptyCoroutineContext_instance2zr761y43akub as EmptyCoroutineContext_instance,
+  Continuation1aa2oekvx7jm7 as Continuation,
+  initMetadataForFunctionReferencen3g5fpj34t8u as initMetadataForFunctionReference,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  CancellationException_init_$Create$2cgg3m6ot6euw as CancellationException_init_$Create$,
+  CancellationException3b36o9qz53rgr as CancellationException,
+  Enum3alwj03lh1n41 as Enum,
+  ArrayList_init_$Create$1jemgvhi5v0js as ArrayList_init_$Create$,
+  listOf1jh22dvmctj1r as listOf,
+  StringBuilder_init_$Create$39ouzl6b47q8d as StringBuilder_init_$Create$,
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  encodeToByteArray22651fhg4p67t as encodeToByteArray,
+  AutoCloseable1l5p57f9lp7kv as AutoCloseable,
+  _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
+  replaceqbix900hl8kl as replace_0,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+  isCharSequence1ju9jr1w86plq as isCharSequence,
+  trim11nh7r46at6sx as trim,
+  toByte4i43936u611k as toByte,
+  decodeToString1x4faah2liw2p as decodeToString,
+  setOf45ia9pnfhe90 as setOf,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  Char__toInt_impl_vasixd3jl92hthlhyn7 as Char__toInt_impl_vasixd,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl,
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  launch1c91vkjzdi9sd as launch,
+  startCoroutineCancellable18shtfwdieib as startCoroutineCancellable,
+  get_job2zvlvce9o9a29 as get_job,
+  Job13y4jkazwjho0 as Job,
+  cancel1xim2hrvjmwpn as cancel,
+  CopyableThrowable1mvc99jcyvivf as CopyableThrowable,
+  Dispatchers_getInstancewbokwrm9sosb as Dispatchers_getInstance,
+} from './kotlinx-coroutines-core.mjs';
+import {
+  Buffergs925ekssbch as Buffer,
+  IOException_init_$Create$3s3kcdlhouh9j as IOException_init_$Create$,
+  indexOf29nspdgx2e3ap as indexOf,
+  EOFException_init_$Create$35zn64u2vfdrf as EOFException_init_$Create$,
+  readString3v6duspiz33tv as readString,
+  readByteString2hnsbql6t4ads as readByteString,
+  readString2nvggcfaijfhd as readString_0,
+  IOException1wyutdmfe71nu as IOException,
+  IOException_init_$Init$1najp4oty5euc as IOException_init_$Init$,
+  IOException_init_$Create$3dh7c73wuug74 as IOException_init_$Create$_0,
+  readByteArray1fhzfwi2j014k as readByteArray,
+  writeString33ca4btrgctw7 as writeString,
+  IOException_init_$Init$wyx5mfudk66d as IOException_init_$Init$_0,
+  readByteArray1ri21h2rciakw as readByteArray_0,
+} from './kotlinx-io-kotlinx-io-core.mjs';
+import { atomic$ref$130aurmcwdfdf1 as atomic$ref$1 } from './kotlinx-atomicfu.mjs';
+import { decodeToString2ede220pr5xir as decodeToString_0 } from './kotlinx-io-kotlinx-io-bytestring.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForCompanion(Companion);
+initMetadataForObject(Empty, 'Empty');
+initMetadataForClass(Closed, 'Closed');
+function resume() {
+  return this.t1e().u8(Companion_getInstance().q1e_1);
+}
+function resume_0(throwable) {
+  var tmp = this.t1e();
+  var tmp_0;
+  if (throwable == null) {
+    tmp_0 = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.Companion.failure' call
+    var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(throwable));
+    tmp_0 = new Result(tmp$ret$2);
+  }
+  var tmp1_elvis_lhs = tmp_0;
+  return tmp.u8(tmp1_elvis_lhs == null ? Companion_getInstance().q1e_1 : tmp1_elvis_lhs.cm_1);
+}
+initMetadataForInterface(Task, 'Task');
+initMetadataForClass(Read, 'Read', VOID, VOID, [Task]);
+initMetadataForClass(Write, 'Write', VOID, VOID, [Task]);
+initMetadataForCoroutine($awaitContentCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($flushCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($flushAndCloseCOROUTINE$, CoroutineImpl);
+function awaitContent$default(min, $completion, $super) {
+  min = min === VOID ? 1 : min;
+  return $super === VOID ? this.a1h(min, $completion) : $super.a1h.call(this, min, $completion);
+}
+initMetadataForInterface(ByteReadChannel_1, 'ByteReadChannel', VOID, VOID, VOID, [1]);
+function get_autoFlush() {
+  return false;
+}
+initMetadataForInterface(ByteWriteChannel, 'ByteWriteChannel', VOID, VOID, VOID, [0]);
+initMetadataForClass(ByteChannel, 'ByteChannel', ByteChannel, VOID, [ByteReadChannel_1, ByteWriteChannel], [1, 0]);
+initMetadataForClass(ConcurrentIOException, 'ConcurrentIOException', VOID, IllegalStateException);
+initMetadataForCoroutine($findNextCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($advanceToNextPotentialMatchCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($checkFullMatchCOROUTINE$, CoroutineImpl);
+initMetadataForClass(ByteChannelScanner, 'ByteChannelScanner', VOID, VOID, VOID, [1, 0]);
+initMetadataForClass(ByteReadChannel$Companion$Empty$1, VOID, VOID, VOID, [ByteReadChannel_1], [1]);
+initMetadataForCompanion(Companion_0);
+initMetadataForCoroutine($readBufferCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($readAvailableCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($readRemainingCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($toByteArrayCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($copyToCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($discardCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($copyToCOROUTINE$_0, CoroutineImpl);
+initMetadataForCoroutine($skipIfFoundCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($readPacketCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($peekCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($internalReadLineToCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($internalReadLineTo$discardCrlfOrCrCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($flushIfNeededCOROUTINE$, CoroutineImpl);
+initMetadataForClass(WriterJob, 'WriterJob');
+initMetadataForClass(WriterScope, 'WriterScope', VOID, VOID, [CoroutineScope]);
+initMetadataForClass(NO_CALLBACK$1, VOID, VOID, VOID, [Continuation]);
+initMetadataForFunctionReference(ByteWriteChannel$flushAndClose$ref, VOID, VOID, [0]);
+initMetadataForLambda(writer$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($writePacketCOROUTINE$, CoroutineImpl);
+initMetadataForClass(CloseToken, 'CloseToken');
+initMetadataForCoroutine($awaitContentCOROUTINE$_0, CoroutineImpl);
+initMetadataForClass(CountedByteReadChannel, 'CountedByteReadChannel', VOID, VOID, [ByteReadChannel_1], [1]);
+initMetadataForClass(ClosedByteChannelException, 'ClosedByteChannelException', ClosedByteChannelException, IOException);
+initMetadataForClass(ClosedReadChannelException, 'ClosedReadChannelException', ClosedReadChannelException, ClosedByteChannelException);
+initMetadataForClass(ClosedWriteChannelException, 'ClosedWriteChannelException', ClosedWriteChannelException, ClosedByteChannelException);
+initMetadataForClass(LineEnding, 'LineEnding', VOID, Enum);
+initMetadataForCompanion(Companion_1);
+initMetadataForClass(LineEndingMode, 'LineEndingMode');
+initMetadataForClass(SourceByteReadChannel, 'SourceByteReadChannel', VOID, VOID, [ByteReadChannel_1], [1]);
+initMetadataForClass(MalformedInputException, 'MalformedInputException', VOID, IOException);
+initMetadataForClass(TooLongLineException, 'TooLongLineException', VOID, MalformedInputException);
+function close() {
+  this.nv();
+}
+initMetadataForInterface(ObjectPool, 'ObjectPool', VOID, VOID, [AutoCloseable]);
+initMetadataForClass(DefaultPool, 'DefaultPool', VOID, VOID, [ObjectPool]);
+initMetadataForClass(ByteArrayPool$1, VOID, VOID, DefaultPool);
+initMetadataForClass(NoPoolImpl, 'NoPoolImpl', VOID, VOID, [ObjectPool]);
+initMetadataForCompanion(Companion_2);
+initMetadataForClass(Charset, 'Charset');
+initMetadataForObject(Charsets, 'Charsets');
+initMetadataForClass(CharsetDecoder, 'CharsetDecoder');
+initMetadataForClass(CharsetEncoder, 'CharsetEncoder');
+initMetadataForClass(CharsetImpl, 'CharsetImpl', VOID, Charset);
+initMetadataForClass(CharsetEncoderImpl, 'CharsetEncoderImpl', VOID, CharsetEncoder);
+initMetadataForClass(CharsetDecoderImpl, 'CharsetDecoderImpl', VOID, CharsetDecoder);
+initMetadataForClass(toKtor$1);
+initMetadataForClass(TextDecoderFallback, 'TextDecoderFallback');
+//endregion
+function Companion() {
+  Companion_instance_0 = this;
+  this.p1e_1 = new Closed(null);
+  var tmp = this;
+  // Inline function 'kotlin.Companion.success' call
+  tmp.q1e_1 = _Result___init__impl__xyqfz8(Unit_instance);
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  if (Companion_instance_0 == null)
+    new Companion();
+  return Companion_instance_0;
+}
+function Empty() {
+}
+protoOf(Empty).toString = function () {
+  return 'Empty';
+};
+protoOf(Empty).hashCode = function () {
+  return -231472095;
+};
+protoOf(Empty).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof Empty))
+    return false;
+  return true;
+};
+var Empty_instance;
+function Empty_getInstance() {
+  return Empty_instance;
+}
+function Closed(cause) {
+  this.r1e_1 = cause;
+}
+protoOf(Closed).toString = function () {
+  return 'Closed(cause=' + toString(this.r1e_1) + ')';
+};
+protoOf(Closed).hashCode = function () {
+  return this.r1e_1 == null ? 0 : hashCode(this.r1e_1);
+};
+protoOf(Closed).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof Closed))
+    return false;
+  if (!equals(this.r1e_1, other.r1e_1))
+    return false;
+  return true;
+};
+function Task() {
+}
+function Read(continuation) {
+  this.x1e_1 = continuation;
+  this.y1e_1 = null;
+  if (get_DEVELOPMENT_MODE()) {
+    var tmp = this;
+    // Inline function 'kotlin.also' call
+    var this_0 = newThrowable('ReadTask 0x' + toString_0(hashCode(this.x1e_1), 16));
+    stackTraceToString(this_0);
+    tmp.y1e_1 = this_0;
+  }
+}
+protoOf(Read).t1e = function () {
+  return this.x1e_1;
+};
+protoOf(Read).s1e = function () {
+  return this.y1e_1;
+};
+protoOf(Read).u1e = function () {
+  return 'read';
+};
+function Write(continuation) {
+  this.z1e_1 = continuation;
+  this.a1f_1 = null;
+  if (get_DEVELOPMENT_MODE()) {
+    var tmp = this;
+    // Inline function 'kotlin.also' call
+    var this_0 = newThrowable('WriteTask 0x' + toString_0(hashCode(this.z1e_1), 16));
+    stackTraceToString(this_0);
+    tmp.a1f_1 = this_0;
+  }
+}
+protoOf(Write).t1e = function () {
+  return this.z1e_1;
+};
+protoOf(Write).s1e = function () {
+  return this.a1f_1;
+};
+protoOf(Write).u1e = function () {
+  return 'write';
+};
+function moveFlushToReadBuffer($this) {
+  // Inline function 'io.ktor.utils.io.locks.synchronized' call
+  $this.e1f_1;
+  $this.c1f_1.up($this.g1f_1);
+  $this.d1f_1 = 0;
+  // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+  var current = $this.f1f_1.kotlinx$atomicfu$value;
+  var tmp;
+  if (current instanceof Write) {
+    tmp = $this.f1f_1.atomicfu$compareAndSet(current, Empty_instance);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    current.v1e();
+  }
+}
+function closeSlot($this, cause) {
+  var closeContinuation = !(cause == null) ? new Closed(cause) : Companion_getInstance().p1e_1;
+  var continuation = $this.f1f_1.atomicfu$getAndSet(closeContinuation);
+  if (isInterface(continuation, Task)) {
+    continuation.w1e(cause);
+  }
+}
+function ClosedReadChannelException$_init_$ref_ix0089() {
+  var l = function (p0) {
+    return new ClosedReadChannelException(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function ClosedWriteChannelException$_init_$ref_ef15ty() {
+  var l = function (p0) {
+    return new ClosedWriteChannelException(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function $awaitContentCOROUTINE$(_this__u8e3s4, min, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.r1f_1 = _this__u8e3s4;
+  this.s1f_1 = min;
+}
+protoOf($awaitContentCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          rethrowCloseCauseIfNeeded(this.r1f_1);
+          if (this.r1f_1.g1f_1.g1() >= fromInt(this.s1f_1))
+            return true;
+          this.t1f_1 = this.r1f_1;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!(add(numberToLong(this.r1f_1.d1f_1), this.r1f_1.g1f_1.g1()) < fromInt(this.s1f_1) && this.r1f_1.i1f_1.kotlinx$atomicfu$value == null)) {
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+          this.j8_1 = 2;
+          var cancellable = new CancellableContinuationImpl(intercepted(this), 1);
+          cancellable.qw();
+          var tmp0 = this.t1f_1;
+          var tmp2 = new Read(cancellable);
+          l$ret$1: do {
+            var previous = tmp0.f1f_1.kotlinx$atomicfu$value;
+            if (!(previous instanceof Closed)) {
+              if (!tmp0.f1f_1.atomicfu$compareAndSet(previous, tmp2)) {
+                tmp2.v1e();
+                break l$ret$1;
+              }
+            }
+            if (previous instanceof Read) {
+              previous.w1e(new ConcurrentIOException(tmp2.u1e(), previous.s1e()));
+            } else {
+              if (isInterface(previous, Task)) {
+                previous.v1e();
+              } else {
+                if (previous instanceof Closed) {
+                  tmp2.w1e(previous.r1e_1);
+                  break l$ret$1;
+                } else {
+                  if (!equals(previous, Empty_instance)) {
+                    noWhenBranchMatchedException();
+                  }
+                }
+              }
+            }
+            if (!(add(numberToLong(this.r1f_1.d1f_1), this.r1f_1.g1f_1.g1()) < fromInt(this.s1f_1) && this.r1f_1.i1f_1.kotlinx$atomicfu$value == null)) {
+              var current = tmp0.f1f_1.kotlinx$atomicfu$value;
+              var tmp_0;
+              if (current instanceof Read) {
+                tmp_0 = tmp0.f1f_1.atomicfu$compareAndSet(current, Empty_instance);
+              } else {
+                tmp_0 = false;
+              }
+              if (tmp_0) {
+                current.v1e();
+              }
+            }
+          }
+           while (false);
+          suspendResult = returnIfSuspended(cancellable.yw(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.j8_1 = 1;
+          continue $sm;
+        case 3:
+          if (this.r1f_1.g1f_1.g1() < 1048576n) {
+            moveFlushToReadBuffer(this.r1f_1);
+          }
+
+          return this.r1f_1.g1f_1.g1() >= fromInt(this.s1f_1);
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 4) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $flushCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.c1g_1 = _this__u8e3s4;
+}
+protoOf($flushCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          rethrowCloseCauseIfNeeded(this.c1g_1);
+          this.c1g_1.e1g();
+          if (this.c1g_1.d1f_1 < 1048576)
+            return Unit_instance;
+          this.d1g_1 = this.c1g_1;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!(this.c1g_1.d1f_1 >= 1048576 && this.c1g_1.i1f_1.kotlinx$atomicfu$value == null)) {
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+          this.j8_1 = 2;
+          var cancellable = new CancellableContinuationImpl(intercepted(this), 1);
+          cancellable.qw();
+          var tmp0 = this.d1g_1;
+          var tmp2 = new Write(cancellable);
+          l$ret$1: do {
+            var previous = tmp0.f1f_1.kotlinx$atomicfu$value;
+            if (!(previous instanceof Closed)) {
+              if (!tmp0.f1f_1.atomicfu$compareAndSet(previous, tmp2)) {
+                tmp2.v1e();
+                break l$ret$1;
+              }
+            }
+            if (previous instanceof Write) {
+              previous.w1e(new ConcurrentIOException(tmp2.u1e(), previous.s1e()));
+            } else {
+              if (isInterface(previous, Task)) {
+                previous.v1e();
+              } else {
+                if (previous instanceof Closed) {
+                  tmp2.w1e(previous.r1e_1);
+                  break l$ret$1;
+                } else {
+                  if (!equals(previous, Empty_instance)) {
+                    noWhenBranchMatchedException();
+                  }
+                }
+              }
+            }
+            if (!(this.c1g_1.d1f_1 >= 1048576 && this.c1g_1.i1f_1.kotlinx$atomicfu$value == null)) {
+              var current = tmp0.f1f_1.kotlinx$atomicfu$value;
+              var tmp_0;
+              if (current instanceof Write) {
+                tmp_0 = tmp0.f1f_1.atomicfu$compareAndSet(current, Empty_instance);
+              } else {
+                tmp_0 = false;
+              }
+              if (tmp_0) {
+                current.v1e();
+              }
+            }
+          }
+           while (false);
+          suspendResult = returnIfSuspended(cancellable.yw(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.j8_1 = 1;
+          continue $sm;
+        case 3:
+          return Unit_instance;
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 4) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $flushAndCloseCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.n1g_1 = _this__u8e3s4;
+}
+protoOf($flushAndCloseCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          var this_0 = this.n1g_1;
+          this.k8_1 = 2;
+          this.p1g_1 = Companion_instance;
+          this.j8_1 = 1;
+          suspendResult = this_0.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var tmp_0 = this;
+          this.p1g_1;
+          tmp_0.o1g_1 = _Result___init__impl__xyqfz8(Unit_instance);
+          this.k8_1 = 4;
+          this.j8_1 = 3;
+          continue $sm;
+        case 2:
+          this.k8_1 = 4;
+          var tmp_1 = this.m8_1;
+          if (tmp_1 instanceof Error) {
+            var e = this.m8_1;
+            var tmp_2 = this;
+            tmp_2.o1g_1 = _Result___init__impl__xyqfz8(createFailure(e));
+            this.j8_1 = 3;
+            continue $sm;
+          } else {
+            throw this.m8_1;
+          }
+
+        case 3:
+          this.k8_1 = 4;
+          if (!this.n1g_1.i1f_1.atomicfu$compareAndSet(null, get_CLOSED()))
+            return Unit_instance;
+          closeSlot(this.n1g_1, null);
+          return Unit_instance;
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e_0 = $p;
+      if (this.k8_1 === 4) {
+        throw e_0;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e_0;
+      }
+    }
+   while (true);
+};
+function ByteChannel(autoFlush) {
+  autoFlush = autoFlush === VOID ? false : autoFlush;
+  this.b1f_1 = autoFlush;
+  this.c1f_1 = new Buffer();
+  this.d1f_1 = 0;
+  this.e1f_1 = new Object();
+  this.f1f_1 = atomic$ref$1(Empty_instance);
+  this.g1f_1 = new Buffer();
+  this.h1f_1 = new Buffer();
+  this.i1f_1 = atomic$ref$1(null);
+}
+protoOf(ByteChannel).r1g = function () {
+  return this.b1f_1;
+};
+protoOf(ByteChannel).s1g = function () {
+  var tmp0_safe_receiver = this.i1f_1.kotlinx$atomicfu$value;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    tmp0_safe_receiver.u1g(ClosedReadChannelException$_init_$ref_ix0089());
+  }
+  if (this.g1f_1.ro()) {
+    moveFlushToReadBuffer(this);
+  }
+  return this.g1f_1;
+};
+protoOf(ByteChannel).v1g = function () {
+  if (this.w1g()) {
+    var tmp0_safe_receiver = this.i1f_1.kotlinx$atomicfu$value;
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      tmp = tmp0_safe_receiver.u1g(ClosedWriteChannelException$_init_$ref_ef15ty());
+    }
+    if (tmp == null)
+      throw new ClosedWriteChannelException();
+  }
+  return this.h1f_1;
+};
+protoOf(ByteChannel).x1g = function () {
+  var tmp0_safe_receiver = this.i1f_1.kotlinx$atomicfu$value;
+  return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y1g();
+};
+protoOf(ByteChannel).w1g = function () {
+  return !(this.i1f_1.kotlinx$atomicfu$value == null);
+};
+protoOf(ByteChannel).z1g = function () {
+  return !(this.x1g() == null) || (this.w1g() && this.d1f_1 === 0 && this.g1f_1.ro());
+};
+protoOf(ByteChannel).a1h = function (min, $completion) {
+  var tmp = new $awaitContentCOROUTINE$(this, min, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(ByteChannel).q1g = function ($completion) {
+  var tmp = new $flushCOROUTINE$(this, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(ByteChannel).e1g = function () {
+  if (this.h1f_1.ro())
+    return Unit_instance;
+  // Inline function 'io.ktor.utils.io.locks.synchronized' call
+  this.e1f_1;
+  var count = convertToInt(this.h1f_1.g1());
+  this.c1f_1.jq(this.h1f_1);
+  this.d1f_1 = this.d1f_1 + count | 0;
+  // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+  var current = this.f1f_1.kotlinx$atomicfu$value;
+  var tmp;
+  if (current instanceof Read) {
+    tmp = this.f1f_1.atomicfu$compareAndSet(current, Empty_instance);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    current.v1e();
+  }
+};
+protoOf(ByteChannel).j4 = function () {
+  this.e1g();
+  if (!this.i1f_1.atomicfu$compareAndSet(null, get_CLOSED()))
+    return Unit_instance;
+  closeSlot(this, null);
+};
+protoOf(ByteChannel).c1h = function ($completion) {
+  var tmp = new $flushAndCloseCOROUTINE$(this, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(ByteChannel).d1h = function (cause) {
+  if (!(this.i1f_1.kotlinx$atomicfu$value == null))
+    return Unit_instance;
+  var closedToken = new CloseToken(cause);
+  this.i1f_1.atomicfu$compareAndSet(null, closedToken);
+  var wrappedCause = closedToken.y1g();
+  closeSlot(this, wrappedCause);
+};
+protoOf(ByteChannel).toString = function () {
+  return 'ByteChannel[' + hashCode(this) + ']';
+};
+function ConcurrentIOException(taskName, cause) {
+  cause = cause === VOID ? null : cause;
+  IllegalStateException_init_$Init$('Concurrent ' + taskName + ' attempts', cause, this);
+  captureStack(this, ConcurrentIOException);
+}
+function ByteReadChannel(content, offset, length) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? content.length : length;
+  // Inline function 'kotlin.also' call
+  var this_0 = new Buffer();
+  this_0.aq(content, offset, offset + length | 0);
+  var source = this_0;
+  return ByteReadChannel_0(source);
+}
+function ByteReadChannel_0(source) {
+  return new SourceByteReadChannel(source);
+}
+function buildPartialMatchTable($this) {
+  var table = new Int32Array($this.f1h_1.g1());
+  var j = 0;
+  var inductionVariable = 1;
+  var last = $this.f1h_1.g1();
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      while (j > 0 && !($this.f1h_1.h1(i) === $this.f1h_1.h1(j))) {
+        j = table[j - 1 | 0];
+      }
+      if ($this.f1h_1.h1(i) === $this.f1h_1.h1(j)) {
+        j = j + 1 | 0;
+      }
+      table[i] = j;
+    }
+     while (inductionVariable < last);
+  return table;
+}
+function advanceToNextPotentialMatch($this, $completion) {
+  var tmp = new $advanceToNextPotentialMatchCOROUTINE$($this, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function checkFullMatch($this, $completion) {
+  var tmp = new $checkFullMatchCOROUTINE$($this, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function checkBounds($this, extra) {
+  if (add($this.l1h_1, extra) > $this.h1h_1) {
+    throw IOException_init_$Create$('Limit of ' + $this.h1h_1.toString() + ' bytes exceeded ' + ('while searching for "' + toSingleLineString($this, $this.f1h_1) + '"'));
+  }
+}
+function toSingleLineString($this, _this__u8e3s4) {
+  return replace(decodeToString_0(_this__u8e3s4), '\n', '\\n');
+}
+function $findNextCOROUTINE$(_this__u8e3s4, ignoreMissing, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.q1i_1 = _this__u8e3s4;
+  this.r1i_1 = ignoreMissing;
+}
+protoOf($findNextCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 9;
+          this.q1i_1.l1h_1 = 0n;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!this.q1i_1.i1h_1.ro()) {
+            this.s1i_1 = true;
+            this.j8_1 = 3;
+            continue $sm;
+          } else {
+            this.j8_1 = 2;
+            suspendResult = this.q1i_1.e1h_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          }
+
+        case 2:
+          this.s1i_1 = suspendResult;
+          this.j8_1 = 3;
+          continue $sm;
+        case 3:
+          if (!this.s1i_1) {
+            this.j8_1 = 7;
+            continue $sm;
+          }
+
+          this.j8_1 = 4;
+          suspendResult = advanceToNextPotentialMatch(this.q1i_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 4:
+          this.j8_1 = 5;
+          suspendResult = checkFullMatch(this.q1i_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 5:
+          if (suspendResult) {
+            return this.q1i_1.l1h_1;
+          } else {
+            this.j8_1 = 6;
+            continue $sm;
+          }
+
+        case 6:
+          this.j8_1 = 1;
+          continue $sm;
+        case 7:
+          if (!this.r1i_1) {
+            throw IOException_init_$Create$('Expected "' + toSingleLineString(this.q1i_1, this.q1i_1.f1h_1) + '" but encountered end of input');
+          }
+
+          this.q1i_1.l1h_1 = add(this.q1i_1.l1h_1, this.q1i_1.k1h_1.up(this.q1i_1.g1h_1.v1g()));
+          this.j8_1 = 8;
+          suspendResult = this.q1i_1.g1h_1.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 8:
+          return this.q1i_1.l1h_1;
+        case 9:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 9) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $advanceToNextPotentialMatchCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.v1h_1 = _this__u8e3s4;
+}
+protoOf($advanceToNextPotentialMatchCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 8;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!this.v1h_1.i1h_1.ro()) {
+            this.w1h_1 = true;
+            this.j8_1 = 3;
+            continue $sm;
+          } else {
+            this.j8_1 = 2;
+            suspendResult = this.v1h_1.e1h_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          }
+
+        case 2:
+          this.w1h_1 = suspendResult;
+          this.j8_1 = 3;
+          continue $sm;
+        case 3:
+          if (!this.w1h_1) {
+            this.j8_1 = 7;
+            continue $sm;
+          }
+
+          var nextMatch = indexOf(this.v1h_1.i1h_1, this.v1h_1.f1h_1.h1(0));
+          if (nextMatch === -1n) {
+            var tmp_0 = this.v1h_1.i1h_1;
+            checkBounds(this.v1h_1, (tmp_0 instanceof Buffer ? tmp_0 : THROW_CCE()).g1());
+            this.v1h_1.l1h_1 = add(this.v1h_1.l1h_1, this.v1h_1.i1h_1.up(this.v1h_1.g1h_1.v1g()));
+            this.j8_1 = 5;
+            suspendResult = flushIfNeeded(this.v1h_1.g1h_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            checkBounds(this.v1h_1, nextMatch);
+            var tmp_1 = this.v1h_1;
+            var tmp_2 = this.v1h_1.l1h_1;
+            var tmp_3 = this.v1h_1.g1h_1.v1g();
+            tmp_1.l1h_1 = add(tmp_2, this.v1h_1.i1h_1.rp(tmp_3 instanceof Buffer ? tmp_3 : THROW_CCE(), nextMatch));
+            this.j8_1 = 4;
+            suspendResult = flushIfNeeded(this.v1h_1.g1h_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          }
+
+        case 4:
+          return Unit_instance;
+        case 5:
+          this.j8_1 = 6;
+          continue $sm;
+        case 6:
+          this.j8_1 = 1;
+          continue $sm;
+        case 7:
+          return Unit_instance;
+        case 8:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 8) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $checkFullMatchCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.f1i_1 = _this__u8e3s4;
+}
+protoOf($checkFullMatchCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 8;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!this.f1i_1.i1h_1.ro()) {
+            this.h1i_1 = true;
+            this.j8_1 = 3;
+            continue $sm;
+          } else {
+            this.j8_1 = 2;
+            suspendResult = this.f1i_1.e1h_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          }
+
+        case 2:
+          this.h1i_1 = suspendResult;
+          this.j8_1 = 3;
+          continue $sm;
+        case 3:
+          if (!this.h1i_1) {
+            this.j8_1 = 7;
+            continue $sm;
+          }
+
+          this.g1i_1 = this.f1i_1.i1h_1.uo();
+          if (this.f1i_1.m1h_1 > 0 && !(this.g1i_1 === this.f1i_1.f1h_1.h1(this.f1i_1.m1h_1))) {
+            var oldMatchIndex = this.f1i_1.m1h_1;
+            while (this.f1i_1.m1h_1 > 0 && !(this.g1i_1 === this.f1i_1.f1h_1.h1(this.f1i_1.m1h_1))) {
+              this.f1i_1.m1h_1 = this.f1i_1.j1h_1[this.f1i_1.m1h_1 - 1 | 0];
+            }
+            var retained = fromInt(oldMatchIndex - this.f1i_1.m1h_1 | 0);
+            checkBounds(this.f1i_1, retained);
+            var tmp_0 = this.f1i_1;
+            var tmp_1 = this.f1i_1.l1h_1;
+            var tmp_2 = this.f1i_1.g1h_1.v1g();
+            tmp_0.l1h_1 = add(tmp_1, this.f1i_1.k1h_1.rp(tmp_2 instanceof Buffer ? tmp_2 : THROW_CCE(), retained));
+            if (this.f1i_1.m1h_1 === 0 && !(this.g1i_1 === this.f1i_1.f1h_1.h1(this.f1i_1.m1h_1))) {
+              this.j8_1 = 6;
+              suspendResult = writeByte(this.f1i_1.g1h_1, this.g1i_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.j8_1 = 4;
+              continue $sm;
+            }
+          } else {
+            this.j8_1 = 5;
+            continue $sm;
+          }
+
+        case 4:
+          this.j8_1 = 5;
+          continue $sm;
+        case 5:
+          this.f1i_1.m1h_1 = this.f1i_1.m1h_1 + 1 | 0;
+          if (this.f1i_1.m1h_1 === this.f1i_1.f1h_1.g1()) {
+            return true;
+          }
+
+          this.f1i_1.k1h_1.kq(this.g1i_1);
+          this.j8_1 = 1;
+          continue $sm;
+        case 6:
+          var _unary__edvuaz = this.f1i_1.l1h_1;
+          this.f1i_1.l1h_1 = add(_unary__edvuaz, get_ONE());
+          return false;
+        case 7:
+          return false;
+        case 8:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 8) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function ByteChannelScanner(channel, matchString, writeChannel, limit) {
+  limit = limit === VOID ? 9223372036854775807n : limit;
+  this.e1h_1 = channel;
+  this.f1h_1 = matchString;
+  this.g1h_1 = writeChannel;
+  this.h1h_1 = limit;
+  // Inline function 'kotlin.require' call
+  if (!(this.f1h_1.g1() > 0)) {
+    var message = 'Empty match string not permitted for scanning';
+    throw IllegalArgumentException_init_$Create$(toString_1(message));
+  }
+  this.i1h_1 = this.e1h_1.s1g();
+  this.j1h_1 = buildPartialMatchTable(this);
+  this.k1h_1 = new Buffer();
+  this.l1h_1 = 0n;
+  this.m1h_1 = 0;
+}
+protoOf(ByteChannelScanner).t1i = function (ignoreMissing, $completion) {
+  var tmp = new $findNextCOROUTINE$(this, ignoreMissing, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+function ByteReadChannel$Companion$Empty$1() {
+  this.u1i_1 = null;
+  this.v1i_1 = new Buffer();
+}
+protoOf(ByteReadChannel$Companion$Empty$1).x1g = function () {
+  return this.u1i_1;
+};
+protoOf(ByteReadChannel$Companion$Empty$1).z1g = function () {
+  return true;
+};
+protoOf(ByteReadChannel$Companion$Empty$1).s1g = function () {
+  return this.v1i_1;
+};
+protoOf(ByteReadChannel$Companion$Empty$1).a1h = function (min, $completion) {
+  return false;
+};
+protoOf(ByteReadChannel$Companion$Empty$1).d1h = function (cause) {
+};
+function Companion_0() {
+  Companion_instance_1 = this;
+  var tmp = this;
+  tmp.w1i_1 = new ByteReadChannel$Companion$Empty$1();
+}
+var Companion_instance_1;
+function Companion_getInstance_0() {
+  if (Companion_instance_1 == null)
+    new Companion_0();
+  return Companion_instance_1;
+}
+function ByteReadChannel_1() {
+}
+function cancel_0(_this__u8e3s4) {
+  _this__u8e3s4.d1h(IOException_init_$Create$('Channel was cancelled'));
+}
+function readBuffer(_this__u8e3s4, $completion) {
+  var tmp = new $readBufferCOROUTINE$(_this__u8e3s4, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function readAvailable(_this__u8e3s4, buffer, offset, length, $completion) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? buffer.length - offset | 0 : length;
+  var tmp = new $readAvailableCOROUTINE$(_this__u8e3s4, buffer, offset, length, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function readRemaining(_this__u8e3s4, $completion) {
+  var tmp = new $readRemainingCOROUTINE$(_this__u8e3s4, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function toByteArray(_this__u8e3s4, $completion) {
+  var tmp = new $toByteArrayCOROUTINE$(_this__u8e3s4, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function copyTo(_this__u8e3s4, channel, limit, $completion) {
+  var tmp = new $copyToCOROUTINE$(_this__u8e3s4, channel, limit, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function discard(_this__u8e3s4, max, $completion) {
+  max = max === VOID ? 9223372036854775807n : max;
+  var tmp = new $discardCOROUTINE$(_this__u8e3s4, max, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function copyTo_0(_this__u8e3s4, channel, $completion) {
+  var tmp = new $copyToCOROUTINE$_0(_this__u8e3s4, channel, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function skipIfFound(_this__u8e3s4, byteString, $completion) {
+  var tmp = new $skipIfFoundCOROUTINE$(_this__u8e3s4, byteString, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function readPacket(_this__u8e3s4, packet, $completion) {
+  var tmp = new $readPacketCOROUTINE$(_this__u8e3s4, packet, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function readUntil(_this__u8e3s4, matchString, writeChannel, limit, ignoreMissing, $completion) {
+  limit = limit === VOID ? 9223372036854775807n : limit;
+  ignoreMissing = ignoreMissing === VOID ? false : ignoreMissing;
+  return (new ByteChannelScanner(_this__u8e3s4, matchString, writeChannel, limit)).t1i(ignoreMissing, $completion);
+}
+function readLineStrictTo(_this__u8e3s4, out, limit, lineEnding, $completion) {
+  limit = limit === VOID ? 9223372036854775807n : limit;
+  lineEnding = lineEnding === VOID ? LineEnding_Default_getInstance() : lineEnding;
+  // Inline function 'kotlin.require' call
+  if (!(limit >= 0n)) {
+    var message = 'Limit (' + limit.toString() + ') should be non-negative';
+    throw IllegalArgumentException_init_$Create$(toString_1(message));
+  }
+  return internalReadLineTo(_this__u8e3s4, out, limit, lineEnding.equals(LineEnding_Lenient_getInstance()), true, $completion);
+}
+function rethrowCloseCauseIfNeeded(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.x1g();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function rethrowCloseCauseIfNeeded_0(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.x1g();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function get_availableForRead(_this__u8e3s4) {
+  return convertToInt(_this__u8e3s4.s1g().qo().g1());
+}
+function peek(_this__u8e3s4, count, $completion) {
+  var tmp = new $peekCOROUTINE$(_this__u8e3s4, count, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function internalReadLineTo(_this__u8e3s4, out, limit, lenientLineEnding, throwOnIncompleteLine, $completion) {
+  var tmp = new $internalReadLineToCOROUTINE$(_this__u8e3s4, out, limit, lenientLineEnding, throwOnIncompleteLine, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function throwEndOfStreamException(consumed) {
+  throw EOFException_init_$Create$('Unexpected end of stream after reading ' + consumed.toString() + ' characters');
+}
+function throwTooLongLineException(limit) {
+  throw new TooLongLineException('Line exceeds limit of ' + limit.toString() + ' characters');
+}
+function rethrowCloseCauseIfNeeded_1(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.x1g();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function internalReadLineTo$transferString(readBuffer, $out, consumed, count) {
+  if (count > 0n) {
+    var string = readString(readBuffer, count);
+    $out.f1(string);
+    var tmp0 = consumed._v;
+    // Inline function 'kotlin.Long.plus' call
+    var other = string.length;
+    consumed._v = add(tmp0, fromInt(other));
+  }
+}
+function internalReadLineTo$scanForSoleCr(_this__u8e3s4, $lenientLineEnding, lfIndex, limitLeft) {
+  if (!$lenientLineEnding)
+    return -1n;
+  var tmp;
+  if (lfIndex === -1n) {
+    // Inline function 'kotlin.Long.minus' call
+    var this_0 = get_remaining(_this__u8e3s4);
+    // Inline function 'kotlin.comparisons.minOf' call
+    var b = subtract(this_0, fromInt(1));
+    tmp = limitLeft <= b ? limitLeft : b;
+  } else if (lfIndex === 0n) {
+    tmp = 0n;
+  } else {
+    // Inline function 'kotlin.Long.minus' call
+    tmp = subtract(lfIndex, fromInt(1));
+  }
+  var endIndex = tmp;
+  return indexOf(_this__u8e3s4, 13, VOID, endIndex);
+}
+function internalReadLineTo$discardCrlfOrCr(_this__u8e3s4, $this_internalReadLineTo, $lenientLineEnding, $completion) {
+  var tmp = new $internalReadLineTo$discardCrlfOrCrCOROUTINE$(_this__u8e3s4, $this_internalReadLineTo, $lenientLineEnding, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function $readBufferCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.f1j_1 = _this__u8e3s4;
+}
+protoOf($readBufferCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          this.g1j_1 = new Buffer();
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!!this.f1j_1.z1g()) {
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+          this.g1j_1.jq(this.f1j_1.s1g());
+          this.j8_1 = 2;
+          suspendResult = this.f1j_1.b1h(VOID, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.j8_1 = 1;
+          continue $sm;
+        case 3:
+          var tmp0_safe_receiver = this.f1j_1.x1g();
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            throw tmp0_safe_receiver;
+          }
+
+          return this.g1j_1;
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 4) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $readAvailableCOROUTINE$(_this__u8e3s4, buffer, offset, length, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.p1j_1 = _this__u8e3s4;
+  this.q1j_1 = buffer;
+  this.r1j_1 = offset;
+  this.s1j_1 = length;
+}
+protoOf($readAvailableCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 3;
+          if (this.p1j_1.z1g())
+            return -1;
+          if (this.p1j_1.s1g().ro()) {
+            this.j8_1 = 1;
+            suspendResult = this.p1j_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j8_1 = 2;
+            continue $sm;
+          }
+
+        case 1:
+          this.j8_1 = 2;
+          continue $sm;
+        case 2:
+          if (this.p1j_1.z1g())
+            return -1;
+          return readAvailable_0(this.p1j_1.s1g(), this.q1j_1, this.r1j_1, this.s1j_1);
+        case 3:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 3) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $readRemainingCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.b1k_1 = _this__u8e3s4;
+}
+protoOf($readRemainingCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          this.c1k_1 = BytePacketBuilder();
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!!this.b1k_1.z1g()) {
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+          this.c1k_1.jq(this.b1k_1.s1g());
+          this.j8_1 = 2;
+          suspendResult = this.b1k_1.b1h(VOID, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.j8_1 = 1;
+          continue $sm;
+        case 3:
+          rethrowCloseCauseIfNeeded_0(this.b1k_1);
+          return this.c1k_1.qo();
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 4) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $toByteArrayCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.l1k_1 = _this__u8e3s4;
+}
+protoOf($toByteArrayCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 2;
+          this.j8_1 = 1;
+          suspendResult = readBuffer(this.l1k_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          return readBytes(ARGUMENT);
+        case 2:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 2) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $copyToCOROUTINE$(_this__u8e3s4, channel, limit, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.u1k_1 = _this__u8e3s4;
+  this.v1k_1 = channel;
+  this.w1k_1 = limit;
+}
+protoOf($copyToCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 12;
+          this.x1k_1 = this.w1k_1;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          this.k8_1 = 8;
+          this.k8_1 = 7;
+          this.j8_1 = 2;
+          continue $sm;
+        case 2:
+          if (!(!this.u1k_1.z1g() && this.x1k_1 > 0n)) {
+            this.j8_1 = 6;
+            continue $sm;
+          }
+
+          if (this.u1k_1.s1g().ro()) {
+            this.j8_1 = 3;
+            suspendResult = this.u1k_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j8_1 = 4;
+            continue $sm;
+          }
+
+        case 3:
+          this.j8_1 = 4;
+          continue $sm;
+        case 4:
+          var tmp0 = this.x1k_1;
+          var b = get_remaining(this.u1k_1.s1g());
+          var count = tmp0 <= b ? tmp0 : b;
+          this.u1k_1.s1g().tp(this.v1k_1.v1g(), count);
+          this.x1k_1 = subtract(this.x1k_1, count);
+          this.j8_1 = 5;
+          suspendResult = this.v1k_1.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 5:
+          this.j8_1 = 2;
+          continue $sm;
+        case 6:
+          this.k8_1 = 12;
+          this.j8_1 = 10;
+          continue $sm;
+        case 7:
+          this.k8_1 = 8;
+          var tmp_0 = this.m8_1;
+          if (tmp_0 instanceof Error) {
+            var cause = this.m8_1;
+            this.u1k_1.d1h(cause);
+            close_0(this.v1k_1, cause);
+            throw cause;
+          } else {
+            throw this.m8_1;
+          }
+
+        case 8:
+          this.k8_1 = 12;
+          this.y1k_1 = this.m8_1;
+          this.j8_1 = 9;
+          suspendResult = this.v1k_1.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 9:
+          throw this.y1k_1;
+        case 10:
+          this.k8_1 = 12;
+          this.j8_1 = 11;
+          suspendResult = this.v1k_1.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 11:
+          return subtract(this.w1k_1, this.x1k_1);
+        case 12:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 12) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $discardCOROUTINE$(_this__u8e3s4, max, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.h1l_1 = _this__u8e3s4;
+  this.i1l_1 = max;
+}
+protoOf($discardCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 5;
+          this.j1l_1 = this.i1l_1;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!(this.j1l_1 > 0n && !this.h1l_1.z1g())) {
+            this.j8_1 = 4;
+            continue $sm;
+          }
+
+          if (get_availableForRead(this.h1l_1) === 0) {
+            this.j8_1 = 2;
+            suspendResult = this.h1l_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+        case 2:
+          this.j8_1 = 3;
+          continue $sm;
+        case 3:
+          var tmp0 = this.j1l_1;
+          var b = get_remaining(this.h1l_1.s1g());
+          var count = tmp0 <= b ? tmp0 : b;
+          discard_0(this.h1l_1.s1g(), count);
+          this.j1l_1 = subtract(this.j1l_1, count);
+          this.j8_1 = 1;
+          continue $sm;
+        case 4:
+          return subtract(this.i1l_1, this.j1l_1);
+        case 5:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 5) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $copyToCOROUTINE$_0(_this__u8e3s4, channel, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.s1l_1 = _this__u8e3s4;
+  this.t1l_1 = channel;
+}
+protoOf($copyToCOROUTINE$_0).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 11;
+          this.u1l_1 = 0n;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          this.k8_1 = 7;
+          this.k8_1 = 6;
+          this.j8_1 = 2;
+          continue $sm;
+        case 2:
+          if (!!this.s1l_1.z1g()) {
+            this.j8_1 = 5;
+            continue $sm;
+          }
+
+          this.u1l_1 = add(this.u1l_1, this.s1l_1.s1g().up(this.t1l_1.v1g()));
+          this.j8_1 = 3;
+          suspendResult = this.t1l_1.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 3:
+          this.j8_1 = 4;
+          suspendResult = this.s1l_1.b1h(VOID, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 4:
+          this.j8_1 = 2;
+          continue $sm;
+        case 5:
+          this.k8_1 = 11;
+          this.j8_1 = 9;
+          continue $sm;
+        case 6:
+          this.k8_1 = 7;
+          var tmp_0 = this.m8_1;
+          if (tmp_0 instanceof Error) {
+            var cause = this.m8_1;
+            this.s1l_1.d1h(cause);
+            close_0(this.t1l_1, cause);
+            throw cause;
+          } else {
+            throw this.m8_1;
+          }
+
+        case 7:
+          this.k8_1 = 11;
+          this.v1l_1 = this.m8_1;
+          this.j8_1 = 8;
+          suspendResult = this.t1l_1.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 8:
+          throw this.v1l_1;
+        case 9:
+          this.k8_1 = 11;
+          this.j8_1 = 10;
+          suspendResult = this.t1l_1.q1g(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 10:
+          return this.u1l_1;
+        case 11:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 11) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $skipIfFoundCOROUTINE$(_this__u8e3s4, byteString, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.e1m_1 = _this__u8e3s4;
+  this.f1m_1 = byteString;
+}
+protoOf($skipIfFoundCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          this.j8_1 = 1;
+          suspendResult = peek(this.e1m_1, this.f1m_1.g1(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          if (equals(ARGUMENT, this.f1m_1)) {
+            this.j8_1 = 3;
+            suspendResult = discard(this.e1m_1, fromInt(this.f1m_1.g1()), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j8_1 = 2;
+            continue $sm;
+          }
+
+        case 2:
+          return false;
+        case 3:
+          return true;
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 4) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $readPacketCOROUTINE$(_this__u8e3s4, packet, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.o1m_1 = _this__u8e3s4;
+  this.p1m_1 = packet;
+}
+protoOf($readPacketCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 6;
+          this.q1m_1 = new Buffer();
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!(this.q1m_1.g1() < fromInt(this.p1m_1))) {
+            this.j8_1 = 5;
+            continue $sm;
+          }
+
+          if (this.o1m_1.s1g().ro()) {
+            this.j8_1 = 2;
+            suspendResult = this.o1m_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+        case 2:
+          this.j8_1 = 3;
+          continue $sm;
+        case 3:
+          if (this.o1m_1.z1g()) {
+            this.j8_1 = 5;
+            continue $sm;
+          } else {
+            this.j8_1 = 4;
+            continue $sm;
+          }
+
+        case 4:
+          if (get_remaining(this.o1m_1.s1g()) > subtract(numberToLong(this.p1m_1), this.q1m_1.g1())) {
+            this.o1m_1.s1g().tp(this.q1m_1, subtract(numberToLong(this.p1m_1), this.q1m_1.g1()));
+          } else {
+            this.o1m_1.s1g().up(this.q1m_1);
+          }
+
+          this.j8_1 = 1;
+          continue $sm;
+        case 5:
+          if (this.q1m_1.g1() < fromInt(this.p1m_1)) {
+            throw EOFException_init_$Create$('Not enough data available, required ' + this.p1m_1 + ' bytes but only ' + this.q1m_1.g1().toString() + ' available');
+          }
+
+          return this.q1m_1;
+        case 6:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 6) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $peekCOROUTINE$(_this__u8e3s4, count, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.z1m_1 = _this__u8e3s4;
+  this.a1n_1 = count;
+}
+protoOf($peekCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 3;
+          if (this.z1m_1.z1g())
+            return null;
+          this.j8_1 = 1;
+          suspendResult = this.z1m_1.a1h(this.a1n_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          if (!suspendResult) {
+            return null;
+          } else {
+            this.j8_1 = 2;
+            continue $sm;
+          }
+
+        case 2:
+          return readByteString(this.z1m_1.s1g().vp(), this.a1n_1);
+        case 3:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 3) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $internalReadLineToCOROUTINE$(_this__u8e3s4, out, limit, lenientLineEnding, throwOnIncompleteLine, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.j1n_1 = _this__u8e3s4;
+  this.k1n_1 = out;
+  this.l1n_1 = limit;
+  this.m1n_1 = lenientLineEnding;
+  this.n1n_1 = throwOnIncompleteLine;
+}
+protoOf($internalReadLineToCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 18;
+          this.p1n_1 = this.j1n_1.s1g();
+          if (this.p1n_1.ro()) {
+            this.j8_1 = 1;
+            suspendResult = this.j1n_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j8_1 = 2;
+            continue $sm;
+          }
+
+        case 1:
+          this.j8_1 = 2;
+          continue $sm;
+        case 2:
+          if (this.j1n_1.z1g())
+            return -1n;
+          this.o1n_1 = {_v: 0n};
+          this.j8_1 = 3;
+          continue $sm;
+        case 3:
+          if (!(this.o1n_1._v < this.l1n_1 && !this.j1n_1.z1g())) {
+            this.j8_1 = 10;
+            continue $sm;
+          }
+
+          var limitLeft = subtract(this.l1n_1, this.o1n_1._v);
+          var lfIndex = indexOf(this.p1n_1, 10, VOID, limitLeft);
+          var crIndex = internalReadLineTo$scanForSoleCr(this.p1n_1, this.m1n_1, lfIndex, limitLeft);
+          if (crIndex >= 0n) {
+            internalReadLineTo$transferString(this.p1n_1, this.k1n_1, this.o1n_1, crIndex);
+            discard_0(this.p1n_1, 1n);
+            return this.o1n_1._v;
+          }
+
+          if (lfIndex === 0n) {
+            discard_0(this.p1n_1, 1n);
+            return this.o1n_1._v;
+          }
+
+          if (lfIndex > 0n) {
+            var tmp_0;
+            var tmp_1 = this.p1n_1.qo();
+            if (tmp_1.mp(subtract(lfIndex, fromInt(1))) === 13) {
+              tmp_0 = 1n;
+            } else {
+              tmp_0 = 0n;
+            }
+            var isCrlf = tmp_0;
+            internalReadLineTo$transferString(this.p1n_1, this.k1n_1, this.o1n_1, subtract(lfIndex, isCrlf));
+            discard_0(this.p1n_1, add(numberToLong(1), isCrlf));
+            return this.o1n_1._v;
+          }
+
+          var b = get_remaining(this.p1n_1);
+          var count = limitLeft <= b ? limitLeft : b;
+          var tmp_2 = this.p1n_1.qo();
+          if (tmp_2.mp(subtract(count, fromInt(1))) === 13) {
+            internalReadLineTo$transferString(this.p1n_1, this.k1n_1, this.o1n_1, subtract(count, fromInt(1)));
+            this.j8_1 = 4;
+            suspendResult = internalReadLineTo$discardCrlfOrCr(this.p1n_1, this.j1n_1, this.m1n_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            internalReadLineTo$transferString(this.p1n_1, this.k1n_1, this.o1n_1, count);
+            this.j8_1 = 6;
+            continue $sm;
+          }
+
+        case 4:
+          if (suspendResult) {
+            return this.o1n_1._v;
+          } else {
+            this.j8_1 = 5;
+            continue $sm;
+          }
+
+        case 5:
+          internalReadLineTo$transferString(this.p1n_1, this.k1n_1, this.o1n_1, 1n);
+          this.j8_1 = 6;
+          continue $sm;
+        case 6:
+          if (this.o1n_1._v < this.l1n_1 && get_remaining(this.p1n_1) === 0n) {
+            this.j8_1 = 7;
+            suspendResult = this.j1n_1.b1h(VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.r1n_1 = false;
+            this.j8_1 = 8;
+            continue $sm;
+          }
+
+        case 7:
+          this.r1n_1 = !suspendResult;
+          this.j8_1 = 8;
+          continue $sm;
+        case 8:
+          if (this.r1n_1) {
+            this.j8_1 = 10;
+            continue $sm;
+          } else {
+            this.j8_1 = 9;
+            continue $sm;
+          }
+
+        case 9:
+          this.j8_1 = 3;
+          continue $sm;
+        case 10:
+          if (this.o1n_1._v === 0n && this.j1n_1.z1g())
+            return -1n;
+          if (!(this.o1n_1._v <= this.l1n_1)) {
+            var message = 'Consumed bytes exceed the limit: ' + this.o1n_1._v.toString() + ' > ' + this.l1n_1.toString() + ". It's an implementation bug, please report it.";
+            throw IllegalStateException_init_$Create$(toString_1(message));
+          }
+
+          if (this.o1n_1._v === this.l1n_1) {
+            if (this.l1n_1 === 9223372036854775807n)
+              throw new TooLongLineException('Max line length exceeded');
+            if (get_remaining(this.p1n_1) === 0n) {
+              this.j8_1 = 12;
+              suspendResult = this.j1n_1.b1h(VOID, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.q1n_1 = false;
+              this.j8_1 = 13;
+              continue $sm;
+            }
+          } else {
+            this.j8_1 = 11;
+            continue $sm;
+          }
+
+        case 11:
+          if (this.n1n_1) {
+            throwEndOfStreamException(this.o1n_1._v);
+          }
+
+          return this.o1n_1._v;
+        case 12:
+          this.q1n_1 = !suspendResult;
+          this.j8_1 = 13;
+          continue $sm;
+        case 13:
+          if (this.q1n_1) {
+            throwEndOfStreamException(this.o1n_1._v);
+          } else {
+            this.j8_1 = 14;
+            continue $sm;
+          }
+
+          break;
+        case 14:
+          var tmp0_subject = this.p1n_1.qo().mp(0n);
+          if (tmp0_subject === 10) {
+            discard_0(this.p1n_1, 1n);
+            return this.o1n_1._v;
+          } else {
+            if (tmp0_subject === 13) {
+              this.j8_1 = 15;
+              suspendResult = internalReadLineTo$discardCrlfOrCr(this.p1n_1, this.j1n_1, this.m1n_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.j8_1 = 17;
+              continue $sm;
+            }
+          }
+
+        case 15:
+          if (suspendResult) {
+            return this.o1n_1._v;
+          } else {
+            this.j8_1 = 16;
+            continue $sm;
+          }
+
+        case 16:
+          this.j8_1 = 17;
+          continue $sm;
+        case 17:
+          throwTooLongLineException(this.l1n_1);
+          break;
+        case 18:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 18) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $internalReadLineTo$discardCrlfOrCrCOROUTINE$(_this__u8e3s4, $this_internalReadLineTo, $lenientLineEnding, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.a1o_1 = _this__u8e3s4;
+  this.b1o_1 = $this_internalReadLineTo;
+  this.c1o_1 = $lenientLineEnding;
+}
+protoOf($internalReadLineTo$discardCrlfOrCrCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 5;
+          if (get_remaining(this.a1o_1) >= 2n) {
+            this.e1o_1 = true;
+            this.j8_1 = 2;
+            continue $sm;
+          } else {
+            this.j8_1 = 1;
+            suspendResult = this.b1o_1.a1h(2, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          }
+
+        case 1:
+          this.e1o_1 = suspendResult;
+          this.j8_1 = 2;
+          continue $sm;
+        case 2:
+          if (this.e1o_1) {
+            this.d1o_1 = this.a1o_1.qo().mp(1n) === 10;
+            this.j8_1 = 3;
+            continue $sm;
+          } else {
+            this.d1o_1 = false;
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+        case 3:
+          if (this.d1o_1) {
+            discard_0(this.a1o_1, 2n);
+            return true;
+          } else {
+            this.j8_1 = 4;
+            continue $sm;
+          }
+
+        case 4:
+          if (this.c1o_1) {
+            discard_0(this.a1o_1, 1n);
+            return true;
+          }
+
+          return false;
+        case 5:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 5) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function ByteWriteChannel() {
+}
+function flushIfNeeded(_this__u8e3s4, $completion) {
+  var tmp = new $flushIfNeededCOROUTINE$(_this__u8e3s4, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function $flushIfNeededCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.n1o_1 = _this__u8e3s4;
+}
+protoOf($flushIfNeededCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 3;
+          rethrowCloseCauseIfNeeded_1(this.n1o_1);
+          if (this.n1o_1.r1g() || get_size(this.n1o_1.v1g()) >= 1048576) {
+            this.j8_1 = 1;
+            suspendResult = this.n1o_1.q1g(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j8_1 = 2;
+            continue $sm;
+          }
+
+        case 1:
+          this.j8_1 = 2;
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        case 3:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 3) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function get_NO_CALLBACK() {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return NO_CALLBACK;
+}
+var NO_CALLBACK;
+function writeFully(_this__u8e3s4, value, startIndex, endIndex, $completion) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  endIndex = endIndex === VOID ? value.length : endIndex;
+  _this__u8e3s4.v1g().aq(value, startIndex, endIndex);
+  return flushIfNeeded(_this__u8e3s4, $completion);
+}
+function WriterJob(channel, job) {
+  this.o1o_1 = channel;
+  this.p1o_1 = job;
+}
+protoOf(WriterJob).zx = function () {
+  return this.p1o_1;
+};
+function writer(_this__u8e3s4, coroutineContext, autoFlush, block) {
+  coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_instance : coroutineContext;
+  autoFlush = autoFlush === VOID ? false : autoFlush;
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return writer_0(_this__u8e3s4, coroutineContext, new ByteChannel(), block);
+}
+function WriterScope(channel, coroutineContext) {
+  this.q1o_1 = channel;
+  this.r1o_1 = coroutineContext;
+}
+protoOf(WriterScope).cs = function () {
+  return this.r1o_1;
+};
+function invokeOnCompletion(_this__u8e3s4, block) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return _this__u8e3s4.zx().et(block);
+}
+function close_0(_this__u8e3s4, cause) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  if (cause == null) {
+    fireAndForget(ByteWriteChannel$flushAndClose$ref_0(_this__u8e3s4));
+  } else {
+    _this__u8e3s4.d1h(cause);
+  }
+}
+function writePacket(_this__u8e3s4, source, $completion) {
+  var tmp = new $writePacketCOROUTINE$(_this__u8e3s4, source, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+}
+function writer_0(_this__u8e3s4, coroutineContext, channel, block) {
+  coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_instance : coroutineContext;
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  // Inline function 'kotlin.apply' call
+  var this_0 = launch(_this__u8e3s4, coroutineContext, VOID, writer$slambda_0(block, channel, null));
+  this_0.et(writer$lambda(channel));
+  var job = this_0;
+  return new WriterJob(channel, job);
+}
+function fireAndForget(_this__u8e3s4) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  startCoroutineCancellable(_this__u8e3s4, get_NO_CALLBACK());
+}
+function writeByte(_this__u8e3s4, value, $completion) {
+  _this__u8e3s4.v1g().kq(value);
+  return flushIfNeeded(_this__u8e3s4, $completion);
+}
+function NO_CALLBACK$1() {
+  this.c1p_1 = EmptyCoroutineContext_instance;
+}
+protoOf(NO_CALLBACK$1).p8 = function () {
+  return this.c1p_1;
+};
+protoOf(NO_CALLBACK$1).q8 = function (result) {
+  return Unit_instance;
+};
+protoOf(NO_CALLBACK$1).u8 = function (result) {
+  return this.q8(result);
+};
+function ByteWriteChannel$flushAndClose$ref(p0) {
+  this.d1p_1 = p0;
+}
+protoOf(ByteWriteChannel$flushAndClose$ref).e1p = function ($completion) {
+  return this.d1p_1.c1h($completion);
+};
+protoOf(ByteWriteChannel$flushAndClose$ref).aa = function ($completion) {
+  return this.e1p($completion);
+};
+function ByteWriteChannel$flushAndClose$ref_0(p0) {
+  var i = new ByteWriteChannel$flushAndClose$ref(p0);
+  var l = function ($completion) {
+    return i.e1p($completion);
+  };
+  l.callableName = 'flushAndClose';
+  l.$arity = 0;
+  return l;
+}
+function writer$slambda($block, $channel, resultContinuation) {
+  this.n1p_1 = $block;
+  this.o1p_1 = $channel;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(writer$slambda).w1p = function ($this$launch, $completion) {
+  var tmp = this.x1p($this$launch, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(writer$slambda).d9 = function (p1, $completion) {
+  return this.w1p((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(writer$slambda).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 14;
+          this.s1p_1 = Job(get_job(this.p1p_1.cs()));
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          this.k8_1 = 4;
+          this.k8_1 = 3;
+          this.j8_1 = 2;
+          suspendResult = this.n1p_1(new WriterScope(this.o1p_1, this.p1p_1.cs().lf(this.s1p_1)), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.s1p_1.uy();
+          var tmp_0;
+          if (get_job(this.p1p_1.cs()).ys()) {
+            this.o1p_1.d1h(get_job(this.p1p_1.cs()).bt());
+            tmp_0 = Unit_instance;
+          }
+
+          this.k8_1 = 14;
+          this.j8_1 = 9;
+          continue $sm;
+        case 3:
+          this.k8_1 = 4;
+          var tmp_1 = this.m8_1;
+          if (tmp_1 instanceof Error) {
+            var cause = this.m8_1;
+            cancel(this.s1p_1, 'Exception thrown while writing to channel', cause);
+            this.o1p_1.d1h(cause);
+            this.k8_1 = 14;
+            this.j8_1 = 9;
+            continue $sm;
+          } else {
+            throw this.m8_1;
+          }
+
+        case 4:
+          this.k8_1 = 14;
+          this.t1p_1 = this.m8_1;
+          this.j8_1 = 5;
+          suspendResult = this.s1p_1.it(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 5:
+          this.p1p_1;
+          this.k8_1 = 7;
+          this.v1p_1 = Companion_instance;
+          this.j8_1 = 6;
+          suspendResult = this.o1p_1.c1h(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 6:
+          var tmp_2 = this;
+          this.v1p_1;
+          tmp_2.u1p_1 = _Result___init__impl__xyqfz8(Unit_instance);
+          this.k8_1 = 14;
+          this.j8_1 = 8;
+          continue $sm;
+        case 7:
+          this.k8_1 = 14;
+          var tmp_3 = this.m8_1;
+          if (tmp_3 instanceof Error) {
+            var e = this.m8_1;
+            var tmp_4 = this;
+            tmp_4.u1p_1 = _Result___init__impl__xyqfz8(createFailure(e));
+            this.j8_1 = 8;
+            continue $sm;
+          } else {
+            throw this.m8_1;
+          }
+
+        case 8:
+          this.k8_1 = 14;
+          throw this.t1p_1;
+        case 9:
+          this.k8_1 = 14;
+          this.j8_1 = 10;
+          suspendResult = this.s1p_1.it(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 10:
+          this.p1p_1;
+          this.k8_1 = 12;
+          this.r1p_1 = Companion_instance;
+          this.j8_1 = 11;
+          suspendResult = this.o1p_1.c1h(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 11:
+          var tmp_5 = this;
+          this.r1p_1;
+          tmp_5.q1p_1 = _Result___init__impl__xyqfz8(Unit_instance);
+          this.k8_1 = 14;
+          this.j8_1 = 13;
+          continue $sm;
+        case 12:
+          this.k8_1 = 14;
+          var tmp_6 = this.m8_1;
+          if (tmp_6 instanceof Error) {
+            var e_0 = this.m8_1;
+            var tmp_7 = this;
+            tmp_7.q1p_1 = _Result___init__impl__xyqfz8(createFailure(e_0));
+            this.j8_1 = 13;
+            continue $sm;
+          } else {
+            throw this.m8_1;
+          }
+
+        case 13:
+          this.k8_1 = 14;
+          return Unit_instance;
+        case 14:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e_1 = $p;
+      if (this.k8_1 === 14) {
+        throw e_1;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e_1;
+      }
+    }
+   while (true);
+};
+protoOf(writer$slambda).x1p = function ($this$launch, completion) {
+  var i = new writer$slambda(this.n1p_1, this.o1p_1, completion);
+  i.p1p_1 = $this$launch;
+  return i;
+};
+function writer$slambda_0($block, $channel, resultContinuation) {
+  var i = new writer$slambda($block, $channel, resultContinuation);
+  var l = function ($this$launch, $completion) {
+    return i.w1p($this$launch, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function writer$lambda($channel) {
+  return function (it) {
+    var tmp;
+    if (!(it == null) && !$channel.w1g()) {
+      $channel.d1h(it);
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+function $writePacketCOROUTINE$(_this__u8e3s4, source, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.a1p_1 = _this__u8e3s4;
+  this.b1p_1 = source;
+}
+protoOf($writePacketCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          this.j8_1 = 1;
+          continue $sm;
+        case 1:
+          if (!!this.b1p_1.ro()) {
+            this.j8_1 = 3;
+            continue $sm;
+          }
+
+          this.a1p_1.v1g().eq(this.b1p_1, get_remaining(this.b1p_1));
+          this.j8_1 = 2;
+          suspendResult = flushIfNeeded(this.a1p_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.j8_1 = 1;
+          continue $sm;
+        case 3:
+          return Unit_instance;
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 4) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+var properties_initialized_ByteWriteChannelOperations_kt_acrf6u;
+function _init_properties_ByteWriteChannelOperations_kt__i7slrs() {
+  if (!properties_initialized_ByteWriteChannelOperations_kt_acrf6u) {
+    properties_initialized_ByteWriteChannelOperations_kt_acrf6u = true;
+    NO_CALLBACK = new NO_CALLBACK$1();
+  }
+}
+function get_CLOSED() {
+  _init_properties_CloseToken_kt__9ucr41();
+  return CLOSED;
+}
+var CLOSED;
+function ClosedByteChannelException$_init_$ref_yjp351() {
+  var l = function (p0) {
+    return new ClosedByteChannelException(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function CloseToken(origin) {
+  this.t1g_1 = origin;
+}
+protoOf(CloseToken).y1p = function (wrap) {
+  var tmp0_subject = this.t1g_1;
+  var tmp;
+  if (tmp0_subject == null) {
+    tmp = null;
+  } else {
+    if (isInterface(tmp0_subject, CopyableThrowable)) {
+      tmp = this.t1g_1.dz();
+    } else {
+      if (tmp0_subject instanceof CancellationException) {
+        tmp = CancellationException_init_$Create$(this.t1g_1.message, this.t1g_1);
+      } else {
+        tmp = wrap(this.t1g_1);
+      }
+    }
+  }
+  return tmp;
+};
+protoOf(CloseToken).y1g = function (wrap, $super) {
+  var tmp;
+  if (wrap === VOID) {
+    tmp = ClosedByteChannelException$_init_$ref_yjp351();
+  } else {
+    tmp = wrap;
+  }
+  wrap = tmp;
+  return $super === VOID ? this.y1p(wrap) : $super.y1p.call(this, wrap);
+};
+protoOf(CloseToken).u1g = function (wrap) {
+  var tmp0_safe_receiver = this.y1p(wrap);
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+  return tmp;
+};
+var properties_initialized_CloseToken_kt_lgg8zn;
+function _init_properties_CloseToken_kt__9ucr41() {
+  if (!properties_initialized_CloseToken_kt_lgg8zn) {
+    properties_initialized_CloseToken_kt_lgg8zn = true;
+    CLOSED = new CloseToken(null);
+  }
+}
+function transferFromDelegate($this) {
+  updateConsumed($this);
+  var appended = $this.a1q_1.jq($this.z1p_1.s1g());
+  $this.b1q_1 = add($this.b1q_1, appended);
+}
+function updateConsumed($this) {
+  $this.c1q_1 = add($this.c1q_1, subtract($this.b1q_1, $this.a1q_1.g1()));
+  $this.b1q_1 = $this.a1q_1.g1();
+}
+function $awaitContentCOROUTINE$_0(_this__u8e3s4, min, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.l1q_1 = _this__u8e3s4;
+  this.m1q_1 = min;
+}
+protoOf($awaitContentCOROUTINE$_0).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 3;
+          if (this.l1q_1.s1g().g1() >= fromInt(this.m1q_1)) {
+            return true;
+          }
+
+          this.j8_1 = 1;
+          suspendResult = this.l1q_1.z1p_1.a1h(this.m1q_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          if (suspendResult) {
+            transferFromDelegate(this.l1q_1);
+            return true;
+          } else {
+            this.j8_1 = 2;
+            continue $sm;
+          }
+
+        case 2:
+          return false;
+        case 3:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 3) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function CountedByteReadChannel(delegate) {
+  this.z1p_1 = delegate;
+  this.a1q_1 = new Buffer();
+  this.b1q_1 = 0n;
+  this.c1q_1 = 0n;
+}
+protoOf(CountedByteReadChannel).n1q = function () {
+  updateConsumed(this);
+  return this.c1q_1;
+};
+protoOf(CountedByteReadChannel).x1g = function () {
+  return this.z1p_1.x1g();
+};
+protoOf(CountedByteReadChannel).z1g = function () {
+  return this.a1q_1.ro() && this.z1p_1.z1g();
+};
+protoOf(CountedByteReadChannel).s1g = function () {
+  transferFromDelegate(this);
+  return this.a1q_1;
+};
+protoOf(CountedByteReadChannel).a1h = function (min, $completion) {
+  var tmp = new $awaitContentCOROUTINE$_0(this, min, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(CountedByteReadChannel).d1h = function (cause) {
+  this.z1p_1.d1h(cause);
+  this.a1q_1.j4();
+};
+function counted(_this__u8e3s4) {
+  return new CountedByteReadChannel(_this__u8e3s4);
+}
+function readText(_this__u8e3s4) {
+  return readString_0(_this__u8e3s4);
+}
+function ClosedByteChannelException(cause) {
+  cause = cause === VOID ? null : cause;
+  IOException_init_$Init$(cause == null ? null : cause.message, cause, this);
+  captureStack(this, ClosedByteChannelException);
+}
+function ClosedReadChannelException(cause) {
+  cause = cause === VOID ? null : cause;
+  ClosedByteChannelException.call(this, cause);
+  captureStack(this, ClosedReadChannelException);
+}
+function ClosedWriteChannelException(cause) {
+  cause = cause === VOID ? null : cause;
+  ClosedByteChannelException.call(this, cause);
+  captureStack(this, ClosedWriteChannelException);
+}
+var LineEnding_Default_instance;
+var LineEnding_Lenient_instance;
+var LineEnding_entriesInitialized;
+function LineEnding_initEntries() {
+  if (LineEnding_entriesInitialized)
+    return Unit_instance;
+  LineEnding_entriesInitialized = true;
+  LineEnding_Default_instance = new LineEnding('Default', 0);
+  LineEnding_Lenient_instance = new LineEnding('Lenient', 1);
+}
+function LineEnding(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function LineEnding_Default_getInstance() {
+  LineEnding_initEntries();
+  return LineEnding_Default_instance;
+}
+function LineEnding_Lenient_getInstance() {
+  LineEnding_initEntries();
+  return LineEnding_Lenient_instance;
+}
+function _LineEndingMode___init__impl__jo5bul(mode) {
+  return mode;
+}
+function _get_mode__dah3bc($this) {
+  return $this;
+}
+function LineEndingMode__contains_impl_q5pr68($this, other) {
+  return (_get_mode__dah3bc($this) | _get_mode__dah3bc(other)) === _get_mode__dah3bc($this);
+}
+function LineEndingMode__plus_impl_ttpz2j($this, other) {
+  return _LineEndingMode___init__impl__jo5bul(_get_mode__dah3bc($this) | _get_mode__dah3bc(other));
+}
+function LineEndingMode__toString_impl_j4h76r($this) {
+  var tmp;
+  if ($this === Companion_getInstance_1().o1q_1) {
+    tmp = 'CR';
+  } else if ($this === Companion_getInstance_1().p1q_1) {
+    tmp = 'LF';
+  } else if ($this === Companion_getInstance_1().q1q_1) {
+    tmp = 'CRLF';
+  } else {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = Companion_getInstance_1().s1q_1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$();
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      var it = element.t1q_1;
+      if (LineEndingMode__contains_impl_q5pr68($this, it)) {
+        destination.e1(element);
+      }
+    }
+    tmp = toString_1(destination);
+  }
+  return tmp;
+}
+function Companion_1() {
+  Companion_instance_2 = this;
+  this.o1q_1 = _LineEndingMode___init__impl__jo5bul(1);
+  this.p1q_1 = _LineEndingMode___init__impl__jo5bul(2);
+  this.q1q_1 = _LineEndingMode___init__impl__jo5bul(4);
+  this.r1q_1 = _LineEndingMode___init__impl__jo5bul(7);
+  this.s1q_1 = listOf([new LineEndingMode(this.o1q_1), new LineEndingMode(this.p1q_1), new LineEndingMode(this.q1q_1)]);
+}
+var Companion_instance_2;
+function Companion_getInstance_1() {
+  if (Companion_instance_2 == null)
+    new Companion_1();
+  return Companion_instance_2;
+}
+function LineEndingMode__hashCode_impl_2mopm4($this) {
+  return $this;
+}
+function LineEndingMode__equals_impl_qyr4nk($this, other) {
+  if (!(other instanceof LineEndingMode))
+    return false;
+  if (!($this === other.t1q_1))
+    return false;
+  return true;
+}
+function LineEndingMode(mode) {
+  Companion_getInstance_1();
+  this.t1q_1 = mode;
+}
+protoOf(LineEndingMode).toString = function () {
+  return LineEndingMode__toString_impl_j4h76r(this.t1q_1);
+};
+protoOf(LineEndingMode).hashCode = function () {
+  return LineEndingMode__hashCode_impl_2mopm4(this.t1q_1);
+};
+protoOf(LineEndingMode).equals = function (other) {
+  return LineEndingMode__equals_impl_qyr4nk(this.t1q_1, other);
+};
+function SourceByteReadChannel(source) {
+  this.u1q_1 = source;
+  this.v1q_1 = null;
+}
+protoOf(SourceByteReadChannel).x1g = function () {
+  var tmp0_safe_receiver = this.v1q_1;
+  return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y1g();
+};
+protoOf(SourceByteReadChannel).z1g = function () {
+  return this.u1q_1.ro();
+};
+protoOf(SourceByteReadChannel).s1g = function () {
+  var tmp0_safe_receiver = this.x1g();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+  return this.u1q_1.qo();
+};
+protoOf(SourceByteReadChannel).a1h = function (min, $completion) {
+  var tmp0_safe_receiver = this.x1g();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+  return this.u1q_1.to(fromInt(min));
+};
+protoOf(SourceByteReadChannel).d1h = function (cause) {
+  if (!(this.v1q_1 == null))
+    return Unit_instance;
+  this.u1q_1.j4();
+  var tmp = this;
+  var tmp1_elvis_lhs = cause == null ? null : cause.message;
+  tmp.v1q_1 = new CloseToken(IOException_init_$Create$_0(tmp1_elvis_lhs == null ? 'Channel was cancelled' : tmp1_elvis_lhs, cause));
+};
+function decode(_this__u8e3s4, input, max) {
+  max = max === VOID ? 2147483647 : max;
+  var tmp0 = fromInt(max);
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = input.qo().g1();
+  var tmp$ret$0 = tmp0 <= b ? tmp0 : b;
+  // Inline function 'kotlin.text.buildString' call
+  var capacity = convertToInt(tmp$ret$0);
+  // Inline function 'kotlin.apply' call
+  var this_0 = StringBuilder_init_$Create$(capacity);
+  decode_0(_this__u8e3s4, input, this_0, max);
+  return this_0.toString();
+}
+function encode(_this__u8e3s4, input, fromIndex, toIndex) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(input) : toIndex;
+  // Inline function 'io.ktor.utils.io.core.buildPacket' call
+  var builder = new Buffer();
+  encodeToImpl(_this__u8e3s4, builder, input, fromIndex, toIndex);
+  return builder;
+}
+function TooLongLineException(message) {
+  MalformedInputException.call(this, message);
+  captureStack(this, TooLongLineException);
+}
+function encodeToImpl(_this__u8e3s4, destination, input, fromIndex, toIndex) {
+  var start = fromIndex;
+  if (start >= toIndex)
+    return Unit_instance;
+  $l$loop: while (true) {
+    var rc = encodeImpl(_this__u8e3s4, input, start, toIndex, destination);
+    // Inline function 'kotlin.check' call
+    if (!(rc >= 0)) {
+      throw IllegalStateException_init_$Create$('Check failed.');
+    }
+    start = start + rc | 0;
+    if (start >= toIndex)
+      break $l$loop;
+  }
+}
+function canRead(_this__u8e3s4) {
+  return !_this__u8e3s4.ro();
+}
+function readBytes(_this__u8e3s4, count) {
+  count = count === VOID ? convertToInt(_this__u8e3s4.g1()) : count;
+  return readByteArray(_this__u8e3s4, count);
+}
+function writeFully_0(_this__u8e3s4, buffer, offset, length) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? buffer.length - offset | 0 : length;
+  _this__u8e3s4.aq(buffer, offset, offset + length | 0);
+}
+function BytePacketBuilder() {
+  return new Buffer();
+}
+function build(_this__u8e3s4) {
+  return _this__u8e3s4.qo();
+}
+function get_size(_this__u8e3s4) {
+  return convertToInt(_this__u8e3s4.qo().g1());
+}
+var ByteReadPacketEmpty;
+function get_remaining(_this__u8e3s4) {
+  _init_properties_ByteReadPacket_kt__28475y();
+  return _this__u8e3s4.qo().g1();
+}
+function takeWhile(_this__u8e3s4, block) {
+  _init_properties_ByteReadPacket_kt__28475y();
+  while (!_this__u8e3s4.ro() && block(_this__u8e3s4.qo())) {
+  }
+}
+function discard_0(_this__u8e3s4, count) {
+  count = count === VOID ? 9223372036854775807n : count;
+  _init_properties_ByteReadPacket_kt__28475y();
+  _this__u8e3s4.to(count);
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = get_remaining(_this__u8e3s4);
+  var countToDiscard = count <= b ? count : b;
+  _this__u8e3s4.qo().op(countToDiscard);
+  return countToDiscard;
+}
+var properties_initialized_ByteReadPacket_kt_hw4st4;
+function _init_properties_ByteReadPacket_kt__28475y() {
+  if (!properties_initialized_ByteReadPacket_kt_hw4st4) {
+    properties_initialized_ByteReadPacket_kt_hw4st4 = true;
+    ByteReadPacketEmpty = new Buffer();
+  }
+}
+function readAvailable_0(_this__u8e3s4, buffer, offset, length) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? buffer.length - offset | 0 : length;
+  var result = _this__u8e3s4.pp(buffer, offset, offset + length | 0);
+  return result === -1 ? 0 : result;
+}
+function readText_0(_this__u8e3s4, charset, max) {
+  charset = charset === VOID ? Charsets_getInstance().w1q_1 : charset;
+  max = max === VOID ? 2147483647 : max;
+  if (charset.equals(Charsets_getInstance().w1q_1)) {
+    if (max === 2147483647)
+      return readString_0(_this__u8e3s4);
+    var tmp0 = _this__u8e3s4.qo().g1();
+    // Inline function 'kotlin.math.min' call
+    var b = fromInt(max);
+    var count = tmp0 <= b ? tmp0 : b;
+    return readString(_this__u8e3s4, count);
+  }
+  return decode(charset.z1q(), _this__u8e3s4, max);
+}
+function toByteArray_0(_this__u8e3s4, charset) {
+  charset = charset === VOID ? Charsets_getInstance().w1q_1 : charset;
+  if (charset.equals(Charsets_getInstance().w1q_1))
+    return encodeToByteArray(_this__u8e3s4, VOID, VOID, true);
+  return encodeToByteArray_0(charset.a1r(), _this__u8e3s4, 0, _this__u8e3s4.length);
+}
+function writeText(_this__u8e3s4, text, fromIndex, toIndex, charset) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(text) : toIndex;
+  charset = charset === VOID ? Charsets_getInstance().w1q_1 : charset;
+  if (charset === Charsets_getInstance().w1q_1) {
+    return writeString(_this__u8e3s4, toString_1(text), fromIndex, toIndex);
+  }
+  encodeToImpl(charset.a1r(), _this__u8e3s4, text, fromIndex, toIndex);
+}
+function get_ByteArrayPool() {
+  _init_properties_ByteArrayPool_kt__kfi3uj();
+  return ByteArrayPool;
+}
+var ByteArrayPool;
+function ByteArrayPool$1() {
+  DefaultPool.call(this, 128);
+}
+protoOf(ByteArrayPool$1).e1r = function () {
+  return new Int8Array(4096);
+};
+var properties_initialized_ByteArrayPool_kt_td6pfh;
+function _init_properties_ByteArrayPool_kt__kfi3uj() {
+  if (!properties_initialized_ByteArrayPool_kt_td6pfh) {
+    properties_initialized_ByteArrayPool_kt_td6pfh = true;
+    ByteArrayPool = new ByteArrayPool$1();
+  }
+}
+function ObjectPool() {
+}
+function NoPoolImpl() {
+}
+protoOf(NoPoolImpl).m1r = function (instance) {
+  return Unit_instance;
+};
+protoOf(NoPoolImpl).nv = function () {
+  return Unit_instance;
+};
+function Companion_2() {
+}
+protoOf(Companion_2).n1r = function (name) {
+  switch (name) {
+    case 'UTF-8':
+    case 'utf-8':
+    case 'UTF8':
+    case 'utf8':
+      return Charsets_getInstance().w1q_1;
+  }
+  var tmp;
+  var tmp_0;
+  switch (name) {
+    case 'ISO-8859-1':
+    case 'iso-8859-1':
+      tmp_0 = true;
+      break;
+    default:
+      // Inline function 'kotlin.let' call
+
+      var it = replace_0(name, _Char___init__impl__6a9atx(95), _Char___init__impl__6a9atx(45));
+      var tmp_1;
+      if (it === 'iso-8859-1') {
+        tmp_1 = true;
+      } else {
+        // Inline function 'kotlin.text.lowercase' call
+        // Inline function 'kotlin.js.asDynamic' call
+        tmp_1 = it.toLowerCase() === 'iso-8859-1';
+      }
+
+      tmp_0 = tmp_1;
+      break;
+  }
+  if (tmp_0) {
+    tmp = true;
+  } else {
+    tmp = name === 'latin1' || name === 'Latin1';
+  }
+  if (tmp) {
+    return Charsets_getInstance().x1q_1;
+  }
+  throw IllegalArgumentException_init_$Create$('Charset ' + name + ' is not supported');
+};
+protoOf(Companion_2).o1r = function (charset) {
+  var tmp;
+  switch (charset) {
+    case 'UTF-8':
+    case 'utf-8':
+    case 'UTF8':
+    case 'utf8':
+      tmp = true;
+      break;
+    default:
+      var tmp_0;
+      var tmp_1;
+      switch (charset) {
+        case 'ISO-8859-1':
+        case 'iso-8859-1':
+          tmp_1 = true;
+          break;
+        default:
+          // Inline function 'kotlin.let' call
+
+          var it = replace_0(charset, _Char___init__impl__6a9atx(95), _Char___init__impl__6a9atx(45));
+          var tmp_2;
+          if (it === 'iso-8859-1') {
+            tmp_2 = true;
+          } else {
+            // Inline function 'kotlin.text.lowercase' call
+            // Inline function 'kotlin.js.asDynamic' call
+            tmp_2 = it.toLowerCase() === 'iso-8859-1';
+          }
+
+          tmp_1 = tmp_2;
+          break;
+      }
+
+      if (tmp_1) {
+        tmp_0 = true;
+      } else {
+        tmp_0 = charset === 'latin1';
+      }
+
+      if (tmp_0) {
+        tmp = true;
+      } else {
+        tmp = false;
+      }
+
+      break;
+  }
+  return tmp;
+};
+var Companion_instance_3;
+function Companion_getInstance_2() {
+  return Companion_instance_3;
+}
+function Charset(_name) {
+  this.y1q_1 = _name;
+}
+protoOf(Charset).equals = function (other) {
+  if (this === other)
+    return true;
+  if (other == null || !(this.constructor == other.constructor))
+    return false;
+  if (!(other instanceof Charset))
+    THROW_CCE();
+  return this.y1q_1 === other.y1q_1;
+};
+protoOf(Charset).hashCode = function () {
+  return getStringHashCode(this.y1q_1);
+};
+protoOf(Charset).toString = function () {
+  return this.y1q_1;
+};
+function Charsets() {
+  Charsets_instance = this;
+  this.w1q_1 = new CharsetImpl('UTF-8');
+  this.x1q_1 = new CharsetImpl('ISO-8859-1');
+}
+var Charsets_instance;
+function Charsets_getInstance() {
+  if (Charsets_instance == null)
+    new Charsets();
+  return Charsets_instance;
+}
+function CharsetDecoder(_charset) {
+  this.p1r_1 = _charset;
+}
+function MalformedInputException(message) {
+  IOException_init_$Init$_0(message, this);
+  captureStack(this, MalformedInputException);
+}
+function get_name(_this__u8e3s4) {
+  return _this__u8e3s4.y1q_1;
+}
+function isSupported(_this__u8e3s4, name) {
+  return Companion_instance_3.o1r(name);
+}
+function forName(_this__u8e3s4, name) {
+  return Companion_instance_3.n1r(name);
+}
+function CharsetEncoder(_charset) {
+  this.q1r_1 = _charset;
+}
+function decode_0(_this__u8e3s4, input, dst, max) {
+  var decoder = Decoder(get_name(get_charset(_this__u8e3s4)), true);
+  var tmp0 = input.qo().g1();
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = fromInt(max);
+  var count = tmp0 <= b ? tmp0 : b;
+  var array = readByteArray(input, convertToInt(count));
+  var tmp;
+  try {
+    // Inline function 'org.khronos.webgl.toInt8Array' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    tmp = decoder.r1r(array);
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof Error) {
+      var cause = $p;
+      var tmp0_elvis_lhs = cause.message;
+      throw new MalformedInputException('Failed to decode bytes: ' + (tmp0_elvis_lhs == null ? 'no cause provided' : tmp0_elvis_lhs));
+    } else {
+      throw $p;
+    }
+  }
+  var result = tmp;
+  dst.f1(result);
+  return result.length;
+}
+function encodeImpl(_this__u8e3s4, input, fromIndex, toIndex, dst) {
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(fromIndex <= toIndex)) {
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString_1(message));
+  }
+  if (get_charset_0(_this__u8e3s4).equals(Charsets_getInstance().x1q_1)) {
+    return encodeISO88591(input, fromIndex, toIndex, dst);
+  }
+  // Inline function 'kotlin.require' call
+  if (!(get_charset_0(_this__u8e3s4) === Charsets_getInstance().w1q_1)) {
+    var message_0 = 'Only UTF-8 encoding is supported in JS';
+    throw IllegalArgumentException_init_$Create$(toString_1(message_0));
+  }
+  var encoder = new TextEncoder();
+  // Inline function 'kotlin.text.substring' call
+  var tmp$ret$5 = toString_1(charSequenceSubSequence(input, fromIndex, toIndex));
+  var result = encoder.encode(tmp$ret$5);
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  dst.dq(result);
+  return result.length;
+}
+function encodeToByteArray_0(_this__u8e3s4, input, fromIndex, toIndex) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(input) : toIndex;
+  return encodeToByteArrayImpl(_this__u8e3s4, input, fromIndex, toIndex);
+}
+function CharsetImpl(name) {
+  Charset.call(this, name);
+}
+protoOf(CharsetImpl).a1r = function () {
+  return new CharsetEncoderImpl(this);
+};
+protoOf(CharsetImpl).z1q = function () {
+  return new CharsetDecoderImpl(this);
+};
+function get_charset(_this__u8e3s4) {
+  return _this__u8e3s4.p1r_1;
+}
+function get_charset_0(_this__u8e3s4) {
+  return _this__u8e3s4.q1r_1;
+}
+function encodeToByteArrayImpl(_this__u8e3s4, input, fromIndex, toIndex) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(input) : toIndex;
+  var start = fromIndex;
+  if (start >= toIndex)
+    return new Int8Array(0);
+  var dst = new Buffer();
+  var rc = encodeImpl(_this__u8e3s4, input, start, toIndex, dst);
+  start = start + rc | 0;
+  if (start === toIndex) {
+    return readByteArray_0(dst);
+  }
+  encodeToImpl(_this__u8e3s4, dst, input, start, toIndex);
+  return readByteArray_0(dst);
+}
+function CharsetEncoderImpl(charset) {
+  CharsetEncoder.call(this, charset);
+  this.u1r_1 = charset;
+}
+protoOf(CharsetEncoderImpl).toString = function () {
+  return 'CharsetEncoderImpl(charset=' + this.u1r_1.toString() + ')';
+};
+protoOf(CharsetEncoderImpl).hashCode = function () {
+  return this.u1r_1.hashCode();
+};
+protoOf(CharsetEncoderImpl).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof CharsetEncoderImpl))
+    return false;
+  if (!this.u1r_1.equals(other.u1r_1))
+    return false;
+  return true;
+};
+function CharsetDecoderImpl(charset) {
+  CharsetDecoder.call(this, charset);
+  this.w1r_1 = charset;
+}
+protoOf(CharsetDecoderImpl).toString = function () {
+  return 'CharsetDecoderImpl(charset=' + this.w1r_1.toString() + ')';
+};
+protoOf(CharsetDecoderImpl).hashCode = function () {
+  return this.w1r_1.hashCode();
+};
+protoOf(CharsetDecoderImpl).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof CharsetDecoderImpl))
+    return false;
+  if (!this.w1r_1.equals(other.w1r_1))
+    return false;
+  return true;
+};
+function Decoder(encoding, fatal) {
+  fatal = fatal === VOID ? true : fatal;
+  var tmp;
+  try {
+    tmp = toKtor(new TextDecoder(encoding, textDecoderOptions(fatal)));
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof Error) {
+      var cause = $p;
+      tmp_0 = new TextDecoderFallback(encoding, fatal);
+    } else {
+      throw $p;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+}
+function toKtor(_this__u8e3s4) {
+  return new toKtor$1(_this__u8e3s4);
+}
+function textDecoderOptions(fatal) {
+  fatal = fatal === VOID ? false : fatal;
+  // Inline function 'kotlin.apply' call
+  var this_0 = new Object();
+  // Inline function 'kotlin.js.asDynamic' call
+  // Inline function 'kotlin.with' call
+  this_0.fatal = fatal;
+  return this_0;
+}
+function toKtor$1($this_toKtor) {
+  this.x1r_1 = $this_toKtor;
+}
+protoOf(toKtor$1).r1r = function (buffer) {
+  return this.x1r_1.decode(buffer);
+};
+function get_ENCODING_ALIASES() {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  return ENCODING_ALIASES;
+}
+var ENCODING_ALIASES;
+function get_REPLACEMENT() {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  return REPLACEMENT;
+}
+var REPLACEMENT;
+function TextDecoderFallback(encoding, fatal) {
+  this.y1r_1 = fatal;
+  // Inline function 'kotlin.text.trim' call
+  // Inline function 'kotlin.text.lowercase' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var requestedEncoding = toString_1(trim(isCharSequence(encoding) ? encoding : THROW_CCE())).toLowerCase();
+  // Inline function 'kotlin.check' call
+  if (!get_ENCODING_ALIASES().h2(requestedEncoding)) {
+    var message = encoding + ' is not supported.';
+    throw IllegalStateException_init_$Create$(toString_1(message));
+  }
+}
+protoOf(TextDecoderFallback).r1r = function (buffer) {
+  // Inline function 'io.ktor.utils.io.core.buildPacket' call
+  var builder = new Buffer();
+  var bytes = buffer instanceof Int8Array ? buffer : THROW_CCE();
+  var inductionVariable = 0;
+  var last = bytes.length;
+  if (inductionVariable < last)
+    $l$loop: do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'org.khronos.webgl.get' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var byte = bytes[index];
+      var point = toCodePoint(byte);
+      if (point < 0) {
+        // Inline function 'kotlin.check' call
+        if (!!this.y1r_1) {
+          var message = 'Invalid character: ' + point;
+          throw IllegalStateException_init_$Create$(toString_1(message));
+        }
+        writeFully_0(builder, get_REPLACEMENT());
+        continue $l$loop;
+      }
+      if (point > 255) {
+        builder.kq(toByte(point >> 8));
+      }
+      builder.kq(toByte(point & 255));
+    }
+     while (inductionVariable < last);
+  return decodeToString(readByteArray_0(builder));
+};
+function toCodePoint(_this__u8e3s4) {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  var value = _this__u8e3s4 & 255;
+  if (isASCII(value)) {
+    return value;
+  }
+  return get_WIN1252_TABLE()[value - 128 | 0];
+}
+function isASCII(_this__u8e3s4) {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  return 0 <= _this__u8e3s4 ? _this__u8e3s4 <= 127 : false;
+}
+var properties_initialized_TextDecoderFallback_js_kt_6rekzk;
+function _init_properties_TextDecoderFallback_js_kt__an7r6m() {
+  if (!properties_initialized_TextDecoderFallback_js_kt_6rekzk) {
+    properties_initialized_TextDecoderFallback_js_kt_6rekzk = true;
+    ENCODING_ALIASES = setOf(['ansi_x3.4-1968', 'ascii', 'cp1252', 'cp819', 'csisolatin1', 'ibm819', 'iso-8859-1', 'iso-ir-100', 'iso8859-1', 'iso88591', 'iso_8859-1', 'iso_8859-1:1987', 'l1', 'latin1', 'us-ascii', 'windows-1252', 'x-cp1252']);
+    // Inline function 'kotlin.byteArrayOf' call
+    REPLACEMENT = new Int8Array([-17, -65, -67]);
+  }
+}
+function get_DEVELOPMENT_MODE() {
+  return false;
+}
+function ioDispatcher() {
+  return Dispatchers_getInstance().r12_1;
+}
+function encodeISO88591(input, fromIndex, toIndex, dst) {
+  if (fromIndex >= toIndex)
+    return 0;
+  var inductionVariable = fromIndex;
+  if (inductionVariable < toIndex)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.code' call
+      var this_0 = charSequenceGet(input, index);
+      var character = Char__toInt_impl_vasixd(this_0);
+      if (character > 255) {
+        failedToMapError(character);
+      }
+      dst.kq(toByte(character));
+    }
+     while (inductionVariable < toIndex);
+  return toIndex - fromIndex | 0;
+}
+function failedToMapError(ch) {
+  throw new MalformedInputException('The character with unicode point ' + ch + " couldn't be mapped to ISO-8859-1 character");
+}
+function get_WIN1252_TABLE() {
+  _init_properties_Win1252Table_kt__tl0v64();
+  return WIN1252_TABLE;
+}
+var WIN1252_TABLE;
+var properties_initialized_Win1252Table_kt_pkmjoq;
+function _init_properties_Win1252Table_kt__tl0v64() {
+  if (!properties_initialized_Win1252Table_kt_pkmjoq) {
+    properties_initialized_Win1252Table_kt_pkmjoq = true;
+    // Inline function 'kotlin.intArrayOf' call
+    WIN1252_TABLE = new Int32Array([8364, -1, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, -1, 381, -1, -1, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, -1, 382, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]);
+  }
+}
+function DefaultPool(capacity) {
+  this.f1r_1 = capacity;
+  var tmp = this;
+  // Inline function 'kotlin.arrayOfNulls' call
+  var size = this.f1r_1;
+  tmp.g1r_1 = Array(size);
+  this.h1r_1 = 0;
+}
+protoOf(DefaultPool).i1r = function (instance) {
+};
+protoOf(DefaultPool).j1r = function (instance) {
+  return instance;
+};
+protoOf(DefaultPool).k1r = function (instance) {
+};
+protoOf(DefaultPool).l1r = function () {
+  if (this.h1r_1 === 0)
+    return this.e1r();
+  this.h1r_1 = this.h1r_1 - 1 | 0;
+  var idx = this.h1r_1;
+  var tmp = this.g1r_1[idx];
+  var instance = !(tmp == null) ? tmp : THROW_CCE();
+  this.g1r_1[idx] = null;
+  return this.j1r(instance);
+};
+protoOf(DefaultPool).m1r = function (instance) {
+  this.k1r(instance);
+  if (this.h1r_1 === this.f1r_1) {
+    this.i1r(instance);
+  } else {
+    var _unary__edvuaz = this.h1r_1;
+    this.h1r_1 = _unary__edvuaz + 1 | 0;
+    this.g1r_1[_unary__edvuaz] = instance;
+  }
+};
+protoOf(DefaultPool).nv = function () {
+  var inductionVariable = 0;
+  var last = this.h1r_1;
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp = this.g1r_1[i];
+      var instance = !(tmp == null) ? tmp : THROW_CCE();
+      this.g1r_1[i] = null;
+      this.i1r(instance);
+    }
+     while (inductionVariable < last);
+  this.h1r_1 = 0;
+};
+//region block: post-declaration
+protoOf(Read).v1e = resume;
+protoOf(Read).w1e = resume_0;
+protoOf(Write).v1e = resume;
+protoOf(Write).w1e = resume_0;
+protoOf(ByteChannel).b1h = awaitContent$default;
+protoOf(ByteReadChannel$Companion$Empty$1).b1h = awaitContent$default;
+protoOf(CountedByteReadChannel).b1h = awaitContent$default;
+protoOf(SourceByteReadChannel).b1h = awaitContent$default;
+protoOf(DefaultPool).j4 = close;
+protoOf(NoPoolImpl).j4 = close;
+//endregion
+//region block: init
+Empty_instance = new Empty();
+Companion_instance_3 = new Companion_2();
+//endregion
+//region block: exports
+export {
+  copyTo as copyTo3z8um8xkg7g1,
+  copyTo_0 as copyTo1gcgz49nvu9ki,
+  readAvailable as readAvailable3vfomv92cg41a,
+  readLineStrictTo as readLineStrictTo28itb6tlpz7zv,
+  readPacket as readPacket1r77mz431qe8y,
+  readRemaining as readRemaininghtnrfi4c8vp0,
+  readUntil as readUntil3k1nh8lpn23ao,
+  skipIfFound as skipIfFound1m8ofwnay4fp9,
+  toByteArray as toByteArray2f7h1d87fvkuc,
+  writeFully as writeFully3jo5sennkizsh,
+  writePacket as writePacket2q073y706j8ob,
+  LineEndingMode__plus_impl_ttpz2j as LineEndingMode__plus_impl_ttpz2j2y4ckcarwdvhq,
+  Charsets_getInstance as Charsets_getInstanceq0o82sizm30g,
+  Companion_getInstance_0 as Companion_getInstance2xdbr0bdtxbh1,
+  Companion_getInstance_1 as Companion_getInstance1jnwy1jx65t7w,
+  MalformedInputException as MalformedInputExceptionbvc6h5ij0ias,
+  decode as decode1t43jmuxrxpmo,
+  encode as encode35e4rpnc94tb5,
+  forName as forName2faodmskqnoz5,
+  isSupported as isSupported2nf870ypy50et,
+  get_name as get_name2f11g4r0d5pxp,
+  BytePacketBuilder as BytePacketBuilder2biodf4wxvlba,
+  build as buildjygoh729rhy8,
+  canRead as canRead1guo8vbveth0f,
+  discard_0 as discard3ugntd47xyll6,
+  readText_0 as readText27783kyxjxi1g,
+  get_remaining as get_remaining1lapv95kcmm0y,
+  get_size as get_size2imoy2jq11jxl,
+  takeWhile as takeWhile34751tcfg6owx,
+  toByteArray_0 as toByteArray1i3ns5jnoqlv6,
+  writeFully_0 as writeFully359t6q8kam2g5,
+  writeText as writeText19qfzm98fbm4l,
+  get_ByteArrayPool as get_ByteArrayPool3f7yrgvqxz9ct,
+  DefaultPool as DefaultPool2gb1fm4epwgu9,
+  NoPoolImpl as NoPoolImplgos9n8jphzjp,
+  ByteChannel as ByteChannel3cxdguezl3lu7,
+  ByteReadChannel as ByteReadChannel1cb89sbyipkce,
+  ByteReadChannel_1 as ByteReadChannel2wzou76jce72d,
+  ClosedByteChannelException as ClosedByteChannelException3il8gfpye60w,
+  WriterScope as WriterScope3b0bo1enaee6b,
+  cancel_0 as canceldn4b3cdqcfny,
+  close_0 as close3semq7pafb42g,
+  counted as counted3iniv3aql3f9n,
+  invokeOnCompletion as invokeOnCompletion1ziuxzoag0iwj,
+  ioDispatcher as ioDispatcher3b9pa3x0duop,
+  readText as readText3frapgncbqrcg,
+  writer as writer1eia5its2a1fh,
+};
+//endregion
+
+//# sourceMappingURL=ktor-ktor-io.mjs.map