@doordeck/doordeck-headless-sdk 0.45.0 → 0.46.0

package/kotlin/ktor-ktor-io.js

@@ -51,12 +51,12 @@
   var CancellationException = kotlin_kotlin.$_$.b9;
   var readString = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.k;
   var StringBuilder_init_$Create$ = kotlin_kotlin.$_$.i1;
-  var toString_0 = kotlin_kotlin.$_$.tb;
   var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.a2;
   var charSequenceLength = kotlin_kotlin.$_$.ea;
   var readByteArray = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.i;
   var readString_0 = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.l;
   var encodeToByteArray = kotlin_kotlin.$_$.oc;
+  var toString_0 = kotlin_kotlin.$_$.tb;
   var writeString = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.m;
   var _Char___init__impl__6a9atx = kotlin_kotlin.$_$.t2;
   var replace = kotlin_kotlin.$_$.gd;
@@ -79,23 +79,22 @@
   initMetadataForObject(Empty, 'Empty');
   initMetadataForClass(Closed, 'Closed');
   function resume() {
-    return this.v1d().o9(Companion_getInstance().t1d_1);
+    return this.w1e().p9(Companion_getInstance().u1e_1);
   }
   function resume_0(throwable) {
-    var tmp = this.v1d();
+    var tmp = this.w1e();
     var tmp_0;
     if (throwable == null) {
       tmp_0 = null;
     } else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       // Inline function 'io.ktor.utils.io.Task.resume.<anonymous>' 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.o9(tmp1_elvis_lhs == null ? Companion_getInstance().t1d_1 : tmp1_elvis_lhs.gk_1);
+    return tmp.p9(tmp1_elvis_lhs == null ? Companion_getInstance().u1e_1 : tmp1_elvis_lhs.xk_1);
   }
   initMetadataForInterface(Task, 'Task');
   initMetadataForClass(Read, 'Read', VOID, VOID, [Task]);
@@ -105,7 +104,7 @@
   initMetadataForCoroutine($flushAndCloseCOROUTINE$2, CoroutineImpl);
   function awaitContent$default(min, $completion, $super) {
     min = min === VOID ? 1 : min;
-    return $super === VOID ? this.z1f(min, $completion) : $super.z1f.call(this, min, $completion);
+    return $super === VOID ? this.e1h(min, $completion) : $super.e1h.call(this, min, $completion);
   }
   initMetadataForInterface(ByteReadChannel_1, 'ByteReadChannel', VOID, VOID, VOID, [1]);
   initMetadataForClass(ByteChannel, 'ByteChannel', ByteChannel, VOID, [ByteReadChannel_1], [1, 0]);
@@ -142,10 +141,10 @@
   //endregion
   function Companion() {
     Companion_instance_0 = this;
-    this.s1d_1 = new Closed(null);
+    this.t1e_1 = new Closed(null);
     var tmp = this;
     // Inline function 'kotlin.Companion.success' call
-    tmp.t1d_1 = _Result___init__impl__xyqfz8(Unit_instance);
+    tmp.u1e_1 = _Result___init__impl__xyqfz8(Unit_instance);
   }
   var Companion_instance_0;
   function Companion_getInstance() {
@@ -174,13 +173,13 @@
     return Empty_instance;
   }
   function Closed(cause) {
-    this.u1d_1 = cause;
+    this.v1e_1 = cause;
   }
   protoOf(Closed).toString = function () {
-    return 'Closed(cause=' + toString(this.u1d_1) + ')';
+    return 'Closed(cause=' + toString(this.v1e_1) + ')';
   };
   protoOf(Closed).hashCode = function () {
-    return this.u1d_1 == null ? 0 : hashCode(this.u1d_1);
+    return this.v1e_1 == null ? 0 : hashCode(this.v1e_1);
   };
   protoOf(Closed).equals = function (other) {
     if (this === other)
@@ -188,101 +187,103 @@
     if (!(other instanceof Closed))
       return false;
     var tmp0_other_with_cast = other instanceof Closed ? other : THROW_CCE();
-    if (!equals(this.u1d_1, tmp0_other_with_cast.u1d_1))
+    if (!equals(this.v1e_1, tmp0_other_with_cast.v1e_1))
       return false;
     return true;
   };
   function Task() {
   }
   function Read(continuation) {
-    this.z1d_1 = continuation;
+    this.a1f_1 = continuation;
   }
-  protoOf(Read).v1d = function () {
-    return this.z1d_1;
+  protoOf(Read).w1e = function () {
+    return this.a1f_1;
   };
-  protoOf(Read).w1d = function () {
+  protoOf(Read).x1e = function () {
     return 'read';
   };
   function Write(continuation) {
-    this.a1e_1 = continuation;
+    this.b1f_1 = continuation;
   }
-  protoOf(Write).v1d = function () {
-    return this.a1e_1;
+  protoOf(Write).w1e = function () {
+    return this.b1f_1;
   };
-  protoOf(Write).w1d = function () {
+  protoOf(Write).x1e = function () {
     return 'write';
   };
   function moveFlushToReadBuffer($this) {
     // Inline function 'io.ktor.utils.io.locks.synchronized' call
-    $this.e1e_1;
-    $this.c1e_1.w1b($this.g1e_1);
-    $this.d1e_1 = 0;
+    $this.f1f_1;
+    // Inline function 'io.ktor.utils.io.ByteChannel.moveFlushToReadBuffer.<anonymous>' call
+    $this.d1f_1.x1c($this.h1f_1);
+    $this.e1f_1 = 0;
     // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
-    var current = $this.f1e_1.kotlinx$atomicfu$value;
+    var current = $this.g1f_1.kotlinx$atomicfu$value;
     var tmp;
     if (current instanceof Write) {
-      tmp = $this.f1e_1.atomicfu$compareAndSet(current, Empty_instance);
+      tmp = $this.g1f_1.atomicfu$compareAndSet(current, Empty_instance);
     } else {
       tmp = false;
     }
     if (tmp) {
-      current.x1d();
+      current.y1e();
     }
   }
   function closeSlot($this, cause) {
-    var closeContinuation = !(cause == null) ? new Closed(cause) : Companion_getInstance().s1d_1;
-    var continuation = $this.f1e_1.atomicfu$getAndSet(closeContinuation);
+    var closeContinuation = !(cause == null) ? new Closed(cause) : Companion_getInstance().t1e_1;
+    var continuation = $this.g1f_1.atomicfu$getAndSet(closeContinuation);
     if (!isInterface(continuation, Task))
       return Unit_instance;
-    continuation.y1d(cause);
+    continuation.z1e(cause);
   }
   function $awaitContentCOROUTINE$0(_this__u8e3s4, min, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.r1e_1 = _this__u8e3s4;
-    this.s1e_1 = min;
+    this.s1f_1 = _this__u8e3s4;
+    this.t1f_1 = min;
   }
-  protoOf($awaitContentCOROUTINE$0).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($awaitContentCOROUTINE$0).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 4;
-            rethrowCloseCauseIfNeeded_1(this.r1e_1);
-            if (numberToLong(this.r1e_1.d1e_1).z2(this.r1e_1.g1e_1.s()).e1(toLong(this.s1e_1)) >= 0)
+            this.f9_1 = 4;
+            rethrowCloseCauseIfNeeded_1(this.s1f_1);
+            if (numberToLong(this.s1f_1.e1f_1).z2(this.s1f_1.h1f_1.s()).e1(toLong(this.t1f_1)) >= 0)
               return true;
             var tmp_0 = this;
-            tmp_0.t1e_1 = this.r1e_1;
-            this.d9_1 = 1;
+            tmp_0.u1f_1 = this.s1f_1;
+            this.v1f_1 = this.u1f_1;
+            this.e9_1 = 1;
             continue $sm;
           case 1:
-            if (!(numberToLong(this.r1e_1.d1e_1).z2(this.r1e_1.g1e_1.s()).e1(toLong(this.s1e_1)) < 0 && this.r1e_1.i1e_1.kotlinx$atomicfu$value == null)) {
-              this.d9_1 = 3;
+            if (!(numberToLong(this.s1f_1.e1f_1).z2(this.s1f_1.h1f_1.s()).e1(toLong(this.t1f_1)) < 0 && this.s1f_1.j1f_1.kotlinx$atomicfu$value == null)) {
+              this.e9_1 = 3;
               continue $sm;
             }
 
-            this.d9_1 = 2;
+            this.e9_1 = 2;
             var cancellable = new CancellableContinuationImpl(intercepted(this), 1);
-            cancellable.zr();
+            cancellable.qs();
+            var tmp0 = this.v1f_1;
+            var tmp1 = new Read(cancellable);
             l$ret$1: do {
-              var this_0 = this.t1e_1;
-              var slot = new Read(cancellable);
-              var previous = this_0.f1e_1.kotlinx$atomicfu$value;
+              var previous = tmp0.g1f_1.kotlinx$atomicfu$value;
               if (!(previous instanceof Closed)) {
-                if (!this_0.f1e_1.atomicfu$compareAndSet(previous, slot)) {
-                  slot.x1d();
+                if (!tmp0.g1f_1.atomicfu$compareAndSet(previous, tmp1)) {
+                  tmp1.y1e();
                   break l$ret$1;
                 }
               }
               if (previous instanceof Read) {
-                previous.y1d(new ConcurrentIOException(slot.w1d()));
+                previous.z1e(new ConcurrentIOException(tmp1.x1e()));
               } else {
                 if (isInterface(previous, Task)) {
-                  previous.x1d();
+                  previous.y1e();
                 } else {
                   if (previous instanceof Closed) {
-                    slot.y1d(previous.u1d_1);
+                    tmp1.z1e(previous.v1e_1);
                     break l$ret$1;
                   } else {
                     if (!equals(previous, Empty_instance)) {
@@ -291,96 +292,97 @@
                   }
                 }
               }
-              if (!(numberToLong(this.r1e_1.d1e_1).z2(this.r1e_1.g1e_1.s()).e1(toLong(this.s1e_1)) < 0 && this.r1e_1.i1e_1.kotlinx$atomicfu$value == null)) {
-                var current = this_0.f1e_1.kotlinx$atomicfu$value;
+              if (!(numberToLong(this.s1f_1.e1f_1).z2(this.s1f_1.h1f_1.s()).e1(toLong(this.t1f_1)) < 0 && this.s1f_1.j1f_1.kotlinx$atomicfu$value == null)) {
+                var current = tmp0.g1f_1.kotlinx$atomicfu$value;
                 var tmp_1;
                 if (current instanceof Read) {
-                  tmp_1 = this_0.f1e_1.atomicfu$compareAndSet(current, Empty_instance);
+                  tmp_1 = tmp0.g1f_1.atomicfu$compareAndSet(current, Empty_instance);
                 } else {
                   tmp_1 = false;
                 }
                 if (tmp_1) {
-                  current.x1d();
+                  current.y1e();
                 }
               }
             }
              while (false);
-            suspendResult = returnIfSuspended(cancellable.hs(), this);
+            suspendResult = returnIfSuspended(cancellable.ys(), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 2:
-            this.d9_1 = 1;
+            this.e9_1 = 1;
             continue $sm;
           case 3:
-            if (this.r1e_1.g1e_1.s().e1(new Long(1048576, 0)) < 0) {
-              moveFlushToReadBuffer(this.r1e_1);
+            if (this.s1f_1.h1f_1.s().e1(new Long(1048576, 0)) < 0) {
+              moveFlushToReadBuffer(this.s1f_1);
             }
 
-            return this.r1e_1.g1e_1.s().e1(toLong(this.s1e_1)) >= 0;
+            return this.s1f_1.h1f_1.s().e1(toLong(this.t1f_1)) >= 0;
           case 4:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 4) {
+        if (this.f9_1 === 4) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function $flushCOROUTINE$1(_this__u8e3s4, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.c1f_1 = _this__u8e3s4;
+    this.e1g_1 = _this__u8e3s4;
   }
-  protoOf($flushCOROUTINE$1).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($flushCOROUTINE$1).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 4;
-            rethrowCloseCauseIfNeeded_1(this.c1f_1);
-            this.c1f_1.e1f();
-            if (this.c1f_1.d1e_1 < 1048576)
+            this.f9_1 = 4;
+            rethrowCloseCauseIfNeeded_1(this.e1g_1);
+            this.e1g_1.h1g();
+            if (this.e1g_1.e1f_1 < 1048576)
               return Unit_instance;
             var tmp_0 = this;
-            tmp_0.d1f_1 = this.c1f_1;
-            this.d9_1 = 1;
+            tmp_0.f1g_1 = this.e1g_1;
+            this.g1g_1 = this.f1g_1;
+            this.e9_1 = 1;
             continue $sm;
           case 1:
-            if (!(this.c1f_1.d1e_1 >= 1048576 && this.c1f_1.i1e_1.kotlinx$atomicfu$value == null)) {
-              this.d9_1 = 3;
+            if (!(this.e1g_1.e1f_1 >= 1048576 && this.e1g_1.j1f_1.kotlinx$atomicfu$value == null)) {
+              this.e9_1 = 3;
               continue $sm;
             }
 
-            this.d9_1 = 2;
+            this.e9_1 = 2;
             var cancellable = new CancellableContinuationImpl(intercepted(this), 1);
-            cancellable.zr();
+            cancellable.qs();
+            var tmp0 = this.g1g_1;
+            var tmp1 = new Write(cancellable);
             l$ret$1: do {
-              var this_0 = this.d1f_1;
-              var slot = new Write(cancellable);
-              var previous = this_0.f1e_1.kotlinx$atomicfu$value;
+              var previous = tmp0.g1f_1.kotlinx$atomicfu$value;
               if (!(previous instanceof Closed)) {
-                if (!this_0.f1e_1.atomicfu$compareAndSet(previous, slot)) {
-                  slot.x1d();
+                if (!tmp0.g1f_1.atomicfu$compareAndSet(previous, tmp1)) {
+                  tmp1.y1e();
                   break l$ret$1;
                 }
               }
               if (previous instanceof Write) {
-                previous.y1d(new ConcurrentIOException(slot.w1d()));
+                previous.z1e(new ConcurrentIOException(tmp1.x1e()));
               } else {
                 if (isInterface(previous, Task)) {
-                  previous.x1d();
+                  previous.y1e();
                 } else {
                   if (previous instanceof Closed) {
-                    slot.y1d(previous.u1d_1);
+                    tmp1.z1e(previous.v1e_1);
                     break l$ret$1;
                   } else {
                     if (!equals(previous, Empty_instance)) {
@@ -389,202 +391,205 @@
                   }
                 }
               }
-              if (!(this.c1f_1.d1e_1 >= 1048576 && this.c1f_1.i1e_1.kotlinx$atomicfu$value == null)) {
-                var current = this_0.f1e_1.kotlinx$atomicfu$value;
+              if (!(this.e1g_1.e1f_1 >= 1048576 && this.e1g_1.j1f_1.kotlinx$atomicfu$value == null)) {
+                var current = tmp0.g1f_1.kotlinx$atomicfu$value;
                 var tmp_1;
                 if (current instanceof Write) {
-                  tmp_1 = this_0.f1e_1.atomicfu$compareAndSet(current, Empty_instance);
+                  tmp_1 = tmp0.g1f_1.atomicfu$compareAndSet(current, Empty_instance);
                 } else {
                   tmp_1 = false;
                 }
                 if (tmp_1) {
-                  current.x1d();
+                  current.y1e();
                 }
               }
             }
              while (false);
-            suspendResult = returnIfSuspended(cancellable.hs(), this);
+            suspendResult = returnIfSuspended(cancellable.ys(), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 2:
-            this.d9_1 = 1;
+            this.e9_1 = 1;
             continue $sm;
           case 3:
             return Unit_instance;
           case 4:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 4) {
+        if (this.f9_1 === 4) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function $flushAndCloseCOROUTINE$2(_this__u8e3s4, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.n1f_1 = _this__u8e3s4;
+    this.q1g_1 = _this__u8e3s4;
   }
-  protoOf($flushAndCloseCOROUTINE$2).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($flushAndCloseCOROUTINE$2).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 4;
+            this.f9_1 = 4;
             var tmp_0 = this;
-            tmp_0.o1f_1 = this.n1f_1;
-            this.e9_1 = 2;
+            tmp_0.r1g_1 = this.q1g_1;
+            this.s1g_1 = this.r1g_1;
+            this.f9_1 = 2;
             var tmp_1 = this;
-            tmp_1.q1f_1 = Companion_instance;
+            tmp_1.u1g_1 = Companion_instance;
             var tmp_2 = this;
-            tmp_2.r1f_1 = this.o1f_1;
-            this.d9_1 = 1;
-            suspendResult = this.r1f_1.s1f(this);
+            tmp_2.v1g_1 = this.s1g_1;
+            this.w1g_1 = this.v1g_1;
+            this.e9_1 = 1;
+            suspendResult = this.w1g_1.x1g(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 1:
-            this.p1f_1 = _Result___init__impl__xyqfz8(Unit_instance);
-            this.e9_1 = 4;
-            this.d9_1 = 3;
+            var tmp_3 = this;
+            this.u1g_1;
+            tmp_3.t1g_1 = _Result___init__impl__xyqfz8(Unit_instance);
+            this.f9_1 = 4;
+            this.e9_1 = 3;
             continue $sm;
           case 2:
-            this.e9_1 = 4;
-            var tmp_3 = this.g9_1;
-            if (tmp_3 instanceof Error) {
-              var e = this.g9_1;
-              var tmp_4 = this;
-              tmp_4.p1f_1 = _Result___init__impl__xyqfz8(createFailure(e));
-              this.d9_1 = 3;
+            this.f9_1 = 4;
+            var tmp_4 = this.h9_1;
+            if (tmp_4 instanceof Error) {
+              var e = this.h9_1;
+              var tmp_5 = this;
+              tmp_5.t1g_1 = _Result___init__impl__xyqfz8(createFailure(e));
+              this.e9_1 = 3;
               continue $sm;
             } else {
-              throw this.g9_1;
+              throw this.h9_1;
             }
 
           case 3:
-            this.e9_1 = 4;
-            if (!this.n1f_1.i1e_1.atomicfu$compareAndSet(null, get_CLOSED()))
+            this.f9_1 = 4;
+            if (!this.q1g_1.j1f_1.atomicfu$compareAndSet(null, get_CLOSED()))
               return Unit_instance;
-            closeSlot(this.n1f_1, null);
+            closeSlot(this.q1g_1, null);
             return Unit_instance;
           case 4:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e_0 = $p;
-        if (this.e9_1 === 4) {
+        if (this.f9_1 === 4) {
           throw e_0;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e_0;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e_0;
         }
       }
      while (true);
   };
   function ByteChannel(autoFlush) {
     autoFlush = autoFlush === VOID ? false : autoFlush;
-    this.b1e_1 = autoFlush;
-    this.c1e_1 = new Buffer();
-    this.d1e_1 = 0;
-    this.e1e_1 = new Object();
-    this.f1e_1 = atomic$ref$1(Empty_instance);
-    this.g1e_1 = new Buffer();
-    this.h1e_1 = new Buffer();
-    this.i1e_1 = atomic$ref$1(null);
-  }
-  protoOf(ByteChannel).t1f = function () {
-    var tmp0_safe_receiver = this.u1f();
+    this.c1f_1 = autoFlush;
+    this.d1f_1 = new Buffer();
+    this.e1f_1 = 0;
+    this.f1f_1 = new Object();
+    this.g1f_1 = atomic$ref$1(Empty_instance);
+    this.h1f_1 = new Buffer();
+    this.i1f_1 = new Buffer();
+    this.j1f_1 = atomic$ref$1(null);
+  }
+  protoOf(ByteChannel).y1g = function () {
+    var tmp0_safe_receiver = this.z1g();
     if (tmp0_safe_receiver == null)
       null;
     else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       throw tmp0_safe_receiver;
     }
-    if (this.g1e_1.u1a()) {
+    if (this.h1f_1.v1b()) {
       moveFlushToReadBuffer(this);
     }
-    return this.g1e_1;
+    return this.h1f_1;
   };
-  protoOf(ByteChannel).v1f = function () {
-    var tmp0_safe_receiver = this.u1f();
+  protoOf(ByteChannel).a1h = function () {
+    var tmp0_safe_receiver = this.z1g();
     if (tmp0_safe_receiver == null)
       null;
     else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       throw tmp0_safe_receiver;
     }
-    if (this.w1f()) {
+    if (this.b1h()) {
       throw IOException_init_$Create$('Channel is closed for write');
     }
-    return this.h1e_1;
+    return this.i1f_1;
   };
-  protoOf(ByteChannel).u1f = function () {
-    var tmp0_safe_receiver = this.i1e_1.kotlinx$atomicfu$value;
-    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u9();
+  protoOf(ByteChannel).z1g = function () {
+    var tmp0_safe_receiver = this.j1f_1.kotlinx$atomicfu$value;
+    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v9();
   };
-  protoOf(ByteChannel).w1f = function () {
-    return !(this.i1e_1.kotlinx$atomicfu$value == null);
+  protoOf(ByteChannel).b1h = function () {
+    return !(this.j1f_1.kotlinx$atomicfu$value == null);
   };
-  protoOf(ByteChannel).y1f = function () {
-    return !(this.u1f() == null) || (this.w1f() && this.d1e_1 === 0 && this.g1e_1.u1a());
+  protoOf(ByteChannel).d1h = function () {
+    return !(this.z1g() == null) || (this.b1h() && this.e1f_1 === 0 && this.h1f_1.v1b());
   };
-  protoOf(ByteChannel).z1f = function (min, $completion) {
+  protoOf(ByteChannel).e1h = function (min, $completion) {
     var tmp = new $awaitContentCOROUTINE$0(this, min, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   };
-  protoOf(ByteChannel).s1f = function ($completion) {
+  protoOf(ByteChannel).x1g = function ($completion) {
     var tmp = new $flushCOROUTINE$1(this, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   };
-  protoOf(ByteChannel).e1f = function () {
-    if (this.h1e_1.u1a())
+  protoOf(ByteChannel).h1g = function () {
+    if (this.i1f_1.v1b())
       return Unit_instance;
     // Inline function 'io.ktor.utils.io.locks.synchronized' call
-    this.e1e_1;
-    var count = this.h1e_1.s().j1();
-    this.c1e_1.k1c(this.h1e_1);
-    this.d1e_1 = this.d1e_1 + count | 0;
+    this.f1f_1;
+    // Inline function 'io.ktor.utils.io.ByteChannel.flushWriteBuffer.<anonymous>' call
+    var count = this.i1f_1.s().j1();
+    this.d1f_1.l1d(this.i1f_1);
+    this.e1f_1 = this.e1f_1 + count | 0;
     // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
-    var current = this.f1e_1.kotlinx$atomicfu$value;
+    var current = this.g1f_1.kotlinx$atomicfu$value;
     var tmp;
     if (current instanceof Read) {
-      tmp = this.f1e_1.atomicfu$compareAndSet(current, Empty_instance);
+      tmp = this.g1f_1.atomicfu$compareAndSet(current, Empty_instance);
     } else {
       tmp = false;
     }
     if (tmp) {
-      current.x1d();
+      current.y1e();
     }
   };
-  protoOf(ByteChannel).b1g = function ($completion) {
+  protoOf(ByteChannel).g1h = function ($completion) {
     var tmp = new $flushAndCloseCOROUTINE$2(this, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   };
-  protoOf(ByteChannel).c1g = function (cause) {
-    if (!(this.i1e_1.kotlinx$atomicfu$value == null))
+  protoOf(ByteChannel).h1h = function (cause) {
+    if (!(this.j1f_1.kotlinx$atomicfu$value == null))
       return Unit_instance;
     var closedToken = new CloseToken(cause);
-    this.i1e_1.atomicfu$compareAndSet(null, closedToken);
-    var actualCause = closedToken.u9();
+    this.j1f_1.atomicfu$compareAndSet(null, closedToken);
+    var actualCause = closedToken.v9();
     closeSlot(this, actualCause);
   };
   protoOf(ByteChannel).toString = function () {
@@ -599,9 +604,8 @@
     length = length === VOID ? content.length : length;
     // Inline function 'kotlin.also' call
     var this_0 = new Buffer();
-    // Inline function 'kotlin.contracts.contract' call
     // Inline function 'io.ktor.utils.io.ByteReadChannel.<anonymous>' call
-    this_0.c1c(content, offset, offset + length | 0);
+    this_0.d1d(content, offset, offset + length | 0);
     var source = this_0;
     return ByteReadChannel_0(source);
   }
@@ -609,27 +613,27 @@
     return new SourceByteReadChannel(source);
   }
   function ByteReadChannel$Companion$Empty$1() {
-    this.d1g_1 = null;
-    this.e1g_1 = new Buffer();
+    this.i1h_1 = null;
+    this.j1h_1 = new Buffer();
   }
-  protoOf(ByteReadChannel$Companion$Empty$1).u1f = function () {
-    return this.d1g_1;
+  protoOf(ByteReadChannel$Companion$Empty$1).z1g = function () {
+    return this.i1h_1;
   };
-  protoOf(ByteReadChannel$Companion$Empty$1).y1f = function () {
+  protoOf(ByteReadChannel$Companion$Empty$1).d1h = function () {
     return true;
   };
-  protoOf(ByteReadChannel$Companion$Empty$1).t1f = function () {
-    return this.e1g_1;
+  protoOf(ByteReadChannel$Companion$Empty$1).y1g = function () {
+    return this.j1h_1;
   };
-  protoOf(ByteReadChannel$Companion$Empty$1).z1f = function (min, $completion) {
+  protoOf(ByteReadChannel$Companion$Empty$1).e1h = function (min, $completion) {
     return false;
   };
-  protoOf(ByteReadChannel$Companion$Empty$1).c1g = function (cause) {
+  protoOf(ByteReadChannel$Companion$Empty$1).h1h = function (cause) {
   };
   function Companion_0() {
     Companion_instance_1 = this;
     var tmp = this;
-    tmp.f1g_1 = new ByteReadChannel$Companion$Empty$1();
+    tmp.k1h_1 = new ByteReadChannel$Companion$Empty$1();
   }
   var Companion_instance_1;
   function Companion_getInstance_0() {
@@ -640,267 +644,264 @@
   function ByteReadChannel_1() {
   }
   function cancel_0(_this__u8e3s4) {
-    _this__u8e3s4.c1g(IOException_init_$Create$('Channel was cancelled'));
+    _this__u8e3s4.h1h(IOException_init_$Create$('Channel was cancelled'));
   }
   function readRemaining(_this__u8e3s4, $completion) {
     var tmp = new $readRemainingCOROUTINE$3(_this__u8e3s4, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   }
   function get_availableForRead(_this__u8e3s4) {
-    return _this__u8e3s4.t1f().t1a().s().j1();
+    return _this__u8e3s4.y1g().u1b().s().j1();
   }
   function readPacket(_this__u8e3s4, packet, $completion) {
     var tmp = new $readPacketCOROUTINE$4(_this__u8e3s4, packet, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   }
   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$7(_this__u8e3s4, buffer, offset, length, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   }
   function toByteArray(_this__u8e3s4, $completion) {
     var tmp = new $toByteArrayCOROUTINE$9(_this__u8e3s4, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   }
   function copyTo(_this__u8e3s4, channel, limit, $completion) {
     var tmp = new $copyToCOROUTINE$10(_this__u8e3s4, channel, limit, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   }
   function rethrowCloseCauseIfNeeded(_this__u8e3s4) {
-    var tmp0_safe_receiver = _this__u8e3s4.u1f();
+    var tmp0_safe_receiver = _this__u8e3s4.z1g();
     if (tmp0_safe_receiver == null)
       null;
     else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       throw tmp0_safe_receiver;
     }
   }
   function readBuffer(_this__u8e3s4, $completion) {
     var tmp = new $readBufferCOROUTINE$12(_this__u8e3s4, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   }
   function rethrowCloseCauseIfNeeded_0(_this__u8e3s4) {
-    var tmp0_safe_receiver = _this__u8e3s4.u1f();
+    var tmp0_safe_receiver = _this__u8e3s4.z1g();
     if (tmp0_safe_receiver == null)
       null;
     else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       throw tmp0_safe_receiver;
     }
   }
   function rethrowCloseCauseIfNeeded_1(_this__u8e3s4) {
-    var tmp0_safe_receiver = _this__u8e3s4.u1f();
+    var tmp0_safe_receiver = _this__u8e3s4.z1g();
     if (tmp0_safe_receiver == null)
       null;
     else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       throw tmp0_safe_receiver;
     }
   }
   function $readRemainingCOROUTINE$3(_this__u8e3s4, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.o1g_1 = _this__u8e3s4;
+    this.t1h_1 = _this__u8e3s4;
   }
-  protoOf($readRemainingCOROUTINE$3).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($readRemainingCOROUTINE$3).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 4;
-            this.p1g_1 = BytePacketBuilder();
-            this.d9_1 = 1;
+            this.f9_1 = 4;
+            this.u1h_1 = BytePacketBuilder();
+            this.e9_1 = 1;
             continue $sm;
           case 1:
-            if (!!this.o1g_1.y1f()) {
-              this.d9_1 = 3;
+            if (!!this.t1h_1.d1h()) {
+              this.e9_1 = 3;
               continue $sm;
             }
 
-            this.p1g_1.k1c(this.o1g_1.t1f());
-            this.d9_1 = 2;
-            suspendResult = this.o1g_1.a1g(VOID, this);
+            this.u1h_1.l1d(this.t1h_1.y1g());
+            this.e9_1 = 2;
+            suspendResult = this.t1h_1.f1h(VOID, this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 2:
-            this.d9_1 = 1;
+            this.e9_1 = 1;
             continue $sm;
           case 3:
-            rethrowCloseCauseIfNeeded(this.o1g_1);
-            return this.p1g_1.t1a();
+            rethrowCloseCauseIfNeeded(this.t1h_1);
+            return this.u1h_1.u1b();
           case 4:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 4) {
+        if (this.f9_1 === 4) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function $readPacketCOROUTINE$4(_this__u8e3s4, packet, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.y1g_1 = _this__u8e3s4;
-    this.z1g_1 = packet;
+    this.d1i_1 = _this__u8e3s4;
+    this.e1i_1 = packet;
   }
-  protoOf($readPacketCOROUTINE$4).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($readPacketCOROUTINE$4).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 6;
-            this.a1h_1 = new Buffer();
-            this.d9_1 = 1;
+            this.f9_1 = 6;
+            this.f1i_1 = new Buffer();
+            this.e9_1 = 1;
             continue $sm;
           case 1:
-            if (!(this.a1h_1.s().e1(toLong(this.z1g_1)) < 0)) {
-              this.d9_1 = 5;
+            if (!(this.f1i_1.s().e1(toLong(this.e1i_1)) < 0)) {
+              this.e9_1 = 5;
               continue $sm;
             }
 
-            if (this.y1g_1.t1f().u1a()) {
-              this.d9_1 = 2;
-              suspendResult = this.y1g_1.a1g(VOID, this);
+            if (this.d1i_1.y1g().v1b()) {
+              this.e9_1 = 2;
+              suspendResult = this.d1i_1.f1h(VOID, this);
               if (suspendResult === get_COROUTINE_SUSPENDED()) {
                 return suspendResult;
               }
               continue $sm;
             } else {
-              this.d9_1 = 3;
+              this.e9_1 = 3;
               continue $sm;
             }
 
           case 2:
-            this.d9_1 = 3;
+            this.e9_1 = 3;
             continue $sm;
           case 3:
-            if (this.y1g_1.y1f()) {
-              this.d9_1 = 5;
+            if (this.d1i_1.d1h()) {
+              this.e9_1 = 5;
               continue $sm;
             } else {
-              this.d9_1 = 4;
+              this.e9_1 = 4;
               continue $sm;
             }
 
           case 4:
-            if (get_remaining(this.y1g_1.t1f()).e1(numberToLong(this.z1g_1).a3(this.a1h_1.s())) > 0) {
-              this.y1g_1.t1f().v1b(this.a1h_1, numberToLong(this.z1g_1).a3(this.a1h_1.s()));
+            if (get_remaining(this.d1i_1.y1g()).e1(numberToLong(this.e1i_1).a3(this.f1i_1.s())) > 0) {
+              this.d1i_1.y1g().w1c(this.f1i_1, numberToLong(this.e1i_1).a3(this.f1i_1.s()));
             } else {
-              this.y1g_1.t1f().w1b(this.a1h_1);
+              this.d1i_1.y1g().x1c(this.f1i_1);
             }
 
-            this.d9_1 = 1;
+            this.e9_1 = 1;
             continue $sm;
           case 5:
-            if (this.a1h_1.s().e1(toLong(this.z1g_1)) < 0) {
-              throw EOFException_init_$Create$('Not enough data available, required ' + this.z1g_1 + ' bytes but only ' + this.a1h_1.s().toString() + ' available');
+            if (this.f1i_1.s().e1(toLong(this.e1i_1)) < 0) {
+              throw EOFException_init_$Create$('Not enough data available, required ' + this.e1i_1 + ' bytes but only ' + this.f1i_1.s().toString() + ' available');
             }
 
-            return this.a1h_1;
+            return this.f1i_1;
           case 6:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 6) {
+        if (this.f9_1 === 6) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function $readAvailableCOROUTINE$7(_this__u8e3s4, buffer, offset, length, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.j1h_1 = _this__u8e3s4;
-    this.k1h_1 = buffer;
-    this.l1h_1 = offset;
-    this.m1h_1 = length;
+    this.o1i_1 = _this__u8e3s4;
+    this.p1i_1 = buffer;
+    this.q1i_1 = offset;
+    this.r1i_1 = length;
   }
-  protoOf($readAvailableCOROUTINE$7).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($readAvailableCOROUTINE$7).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 3;
-            if (this.j1h_1.y1f())
+            this.f9_1 = 3;
+            if (this.o1i_1.d1h())
               return -1;
-            if (this.j1h_1.t1f().u1a()) {
-              this.d9_1 = 1;
-              suspendResult = this.j1h_1.a1g(VOID, this);
+            if (this.o1i_1.y1g().v1b()) {
+              this.e9_1 = 1;
+              suspendResult = this.o1i_1.f1h(VOID, this);
               if (suspendResult === get_COROUTINE_SUSPENDED()) {
                 return suspendResult;
               }
               continue $sm;
             } else {
-              this.d9_1 = 2;
+              this.e9_1 = 2;
               continue $sm;
             }
 
           case 1:
-            this.d9_1 = 2;
+            this.e9_1 = 2;
             continue $sm;
           case 2:
-            if (this.j1h_1.y1f())
+            if (this.o1i_1.d1h())
               return -1;
-            return readAvailable_0(this.j1h_1.t1f(), this.k1h_1, this.l1h_1, this.m1h_1);
+            return readAvailable_0(this.o1i_1.y1g(), this.p1i_1, this.q1i_1, this.r1i_1);
           case 3:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 3) {
+        if (this.f9_1 === 3) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function $toByteArrayCOROUTINE$9(_this__u8e3s4, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.v1h_1 = _this__u8e3s4;
+    this.a1j_1 = _this__u8e3s4;
   }
-  protoOf($toByteArrayCOROUTINE$9).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($toByteArrayCOROUTINE$9).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 2;
-            this.d9_1 = 1;
-            suspendResult = readBuffer(this.v1h_1, this);
+            this.f9_1 = 2;
+            this.e9_1 = 1;
+            suspendResult = readBuffer(this.a1j_1, this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -910,244 +911,244 @@
             var ARGUMENT = suspendResult;
             return readBytes(ARGUMENT);
           case 2:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 2) {
+        if (this.f9_1 === 2) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function $copyToCOROUTINE$10(_this__u8e3s4, channel, limit, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.e1i_1 = _this__u8e3s4;
-    this.f1i_1 = channel;
-    this.g1i_1 = limit;
+    this.j1j_1 = _this__u8e3s4;
+    this.k1j_1 = channel;
+    this.l1j_1 = limit;
   }
-  protoOf($copyToCOROUTINE$10).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($copyToCOROUTINE$10).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 12;
-            this.h1i_1 = this.g1i_1;
-            this.d9_1 = 1;
+            this.f9_1 = 12;
+            this.m1j_1 = this.l1j_1;
+            this.e9_1 = 1;
             continue $sm;
           case 1:
-            this.e9_1 = 8;
-            this.e9_1 = 7;
-            this.d9_1 = 2;
+            this.f9_1 = 8;
+            this.f9_1 = 7;
+            this.e9_1 = 2;
             continue $sm;
           case 2:
-            if (!(!this.e1i_1.y1f() && this.h1i_1.e1(new Long(0, 0)) > 0)) {
-              this.d9_1 = 6;
+            if (!(!this.j1j_1.d1h() && this.m1j_1.e1(new Long(0, 0)) > 0)) {
+              this.e9_1 = 6;
               continue $sm;
             }
 
-            if (this.e1i_1.t1f().u1a()) {
-              this.d9_1 = 3;
-              suspendResult = this.e1i_1.a1g(VOID, this);
+            if (this.j1j_1.y1g().v1b()) {
+              this.e9_1 = 3;
+              suspendResult = this.j1j_1.f1h(VOID, this);
               if (suspendResult === get_COROUTINE_SUSPENDED()) {
                 return suspendResult;
               }
               continue $sm;
             } else {
-              this.d9_1 = 4;
+              this.e9_1 = 4;
               continue $sm;
             }
 
           case 3:
-            this.d9_1 = 4;
+            this.e9_1 = 4;
             continue $sm;
           case 4:
             var tmp_0 = this;
-            var a = this.h1i_1;
-            var b = get_remaining(this.e1i_1.t1f());
-            tmp_0.j1i_1 = a.e1(b) <= 0 ? a : b;
-            this.e1i_1.t1f().v1b(this.f1i_1.v1f(), this.j1i_1);
-            this.h1i_1 = this.h1i_1.a3(this.j1i_1);
-            this.d9_1 = 5;
-            suspendResult = this.f1i_1.s1f(this);
+            var tmp0 = this.m1j_1;
+            var b = get_remaining(this.j1j_1.y1g());
+            tmp_0.o1j_1 = tmp0.e1(b) <= 0 ? tmp0 : b;
+            this.j1j_1.y1g().w1c(this.k1j_1.a1h(), this.o1j_1);
+            this.m1j_1 = this.m1j_1.a3(this.o1j_1);
+            this.e9_1 = 5;
+            suspendResult = this.k1j_1.x1g(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 5:
-            this.d9_1 = 2;
+            this.e9_1 = 2;
             continue $sm;
           case 6:
-            this.i1i_1 = Unit_instance;
-            this.e9_1 = 12;
-            this.d9_1 = 10;
+            this.n1j_1 = Unit_instance;
+            this.f9_1 = 12;
+            this.e9_1 = 10;
             continue $sm;
           case 7:
-            this.e9_1 = 8;
-            var tmp_1 = this.g9_1;
+            this.f9_1 = 8;
+            var tmp_1 = this.h9_1;
             if (tmp_1 instanceof Error) {
-              this.k1i_1 = this.g9_1;
+              this.p1j_1 = this.h9_1;
               var tmp_2 = this;
-              this.e1i_1.c1g(this.k1i_1);
-              close(this.f1i_1, this.k1i_1);
-              throw this.k1i_1;
+              this.j1j_1.h1h(this.p1j_1);
+              close(this.k1j_1, this.p1j_1);
+              throw this.p1j_1;
             } else {
-              throw this.g9_1;
+              throw this.h9_1;
             }
 
           case 8:
-            this.e9_1 = 12;
-            this.l1i_1 = this.g9_1;
-            this.d9_1 = 9;
-            suspendResult = this.f1i_1.s1f(this);
+            this.f9_1 = 12;
+            this.q1j_1 = this.h9_1;
+            this.e9_1 = 9;
+            suspendResult = this.k1j_1.x1g(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 9:
-            throw this.l1i_1;
+            throw this.q1j_1;
           case 10:
-            this.e9_1 = 12;
-            this.d9_1 = 11;
-            suspendResult = this.f1i_1.s1f(this);
+            this.f9_1 = 12;
+            this.e9_1 = 11;
+            suspendResult = this.k1j_1.x1g(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 11:
-            return this.g1i_1.a3(this.h1i_1);
+            return this.l1j_1.a3(this.m1j_1);
           case 12:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 12) {
+        if (this.f9_1 === 12) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function $readBufferCOROUTINE$12(_this__u8e3s4, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.u1i_1 = _this__u8e3s4;
+    this.z1j_1 = _this__u8e3s4;
   }
-  protoOf($readBufferCOROUTINE$12).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($readBufferCOROUTINE$12).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 4;
-            this.v1i_1 = new Buffer();
-            this.d9_1 = 1;
+            this.f9_1 = 4;
+            this.a1k_1 = new Buffer();
+            this.e9_1 = 1;
             continue $sm;
           case 1:
-            if (!!this.u1i_1.y1f()) {
-              this.d9_1 = 3;
+            if (!!this.z1j_1.d1h()) {
+              this.e9_1 = 3;
               continue $sm;
             }
 
-            this.v1i_1.k1c(this.u1i_1.t1f());
-            this.d9_1 = 2;
-            suspendResult = this.u1i_1.a1g(VOID, this);
+            this.a1k_1.l1d(this.z1j_1.y1g());
+            this.e9_1 = 2;
+            suspendResult = this.z1j_1.f1h(VOID, this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 2:
-            this.d9_1 = 1;
+            this.e9_1 = 1;
             continue $sm;
           case 3:
-            var tmp0_safe_receiver = this.u1i_1.u1f();
+            var tmp0_safe_receiver = this.z1j_1.z1g();
             if (tmp0_safe_receiver == null)
               null;
             else {
               throw tmp0_safe_receiver;
             }
 
-            return this.v1i_1;
+            return this.a1k_1;
           case 4:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 4) {
+        if (this.f9_1 === 4) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
   };
   function flushIfNeeded(_this__u8e3s4, $completion) {
     var tmp = new $flushIfNeededCOROUTINE$14(_this__u8e3s4, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   }
   function $flushIfNeededCOROUTINE$14(_this__u8e3s4, resultContinuation) {
     CoroutineImpl.call(this, resultContinuation);
-    this.e1j_1 = _this__u8e3s4;
+    this.j1k_1 = _this__u8e3s4;
   }
-  protoOf($flushIfNeededCOROUTINE$14).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf($flushIfNeededCOROUTINE$14).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 3;
-            rethrowCloseCauseIfNeeded_0(this.e1j_1);
+            this.f9_1 = 3;
+            rethrowCloseCauseIfNeeded_0(this.j1k_1);
             var tmp_0;
-            var tmp_1 = this.e1j_1;
+            var tmp_1 = this.j1k_1;
             var tmp0_safe_receiver = tmp_1 instanceof ByteChannel ? tmp_1 : null;
-            if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.b1e_1) === true) {
+            if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.c1f_1) === true) {
               tmp_0 = true;
             } else {
-              tmp_0 = get_size(this.e1j_1.v1f()) >= 1048576;
+              tmp_0 = get_size(this.j1k_1.a1h()) >= 1048576;
             }
 
             if (tmp_0) {
-              this.d9_1 = 1;
-              suspendResult = this.e1j_1.s1f(this);
+              this.e9_1 = 1;
+              suspendResult = this.j1k_1.x1g(this);
               if (suspendResult === get_COROUTINE_SUSPENDED()) {
                 return suspendResult;
               }
               continue $sm;
             } else {
-              this.d9_1 = 2;
+              this.e9_1 = 2;
               continue $sm;
             }
 
           case 1:
-            this.d9_1 = 2;
+            this.e9_1 = 2;
             continue $sm;
           case 2:
             return Unit_instance;
           case 3:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e = $p;
-        if (this.e9_1 === 3) {
+        if (this.f9_1 === 3) {
           throw e;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e;
         }
       }
      while (true);
@@ -1158,11 +1159,11 @@
   }
   var NO_CALLBACK;
   function WriterJob(channel, job) {
-    this.f1j_1 = channel;
-    this.g1j_1 = job;
+    this.k1k_1 = channel;
+    this.l1k_1 = job;
   }
-  protoOf(WriterJob).it = function () {
-    return this.g1j_1;
+  protoOf(WriterJob).zt = function () {
+    return this.l1k_1;
   };
   function writer(_this__u8e3s4, coroutineContext, autoFlush, block) {
     coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_getInstance() : coroutineContext;
@@ -1171,47 +1172,46 @@
     return writer_0(_this__u8e3s4, coroutineContext, new ByteChannel(), block);
   }
   function WriterScope(channel, coroutineContext) {
-    this.h1j_1 = channel;
-    this.i1j_1 = coroutineContext;
+    this.m1k_1 = channel;
+    this.n1k_1 = coroutineContext;
   }
-  protoOf(WriterScope).jn = function () {
-    return this.i1j_1;
+  protoOf(WriterScope).ao = function () {
+    return this.n1k_1;
   };
   function writeFully(_this__u8e3s4, value, startIndex, endIndex, $completion) {
     startIndex = startIndex === VOID ? 0 : startIndex;
     endIndex = endIndex === VOID ? value.length : endIndex;
-    _this__u8e3s4.v1f().c1c(value, startIndex, endIndex);
+    _this__u8e3s4.a1h().d1d(value, startIndex, endIndex);
     return flushIfNeeded(_this__u8e3s4, $completion);
   }
   function writePacket(_this__u8e3s4, copy, $completion) {
-    _this__u8e3s4.v1f().k1c(copy);
+    _this__u8e3s4.a1h().l1d(copy);
     return flushIfNeeded(_this__u8e3s4, $completion);
   }
   function get_isCompleted(_this__u8e3s4) {
     _init_properties_ByteWriteChannelOperations_kt__i7slrs();
-    return _this__u8e3s4.it().eo();
+    return _this__u8e3s4.zt().vo();
   }
   function close(_this__u8e3s4, cause) {
     _init_properties_ByteWriteChannelOperations_kt__i7slrs();
     if (cause == null) {
       fireAndForget(ByteWriteChannel$flushAndClose$ref_0(_this__u8e3s4));
     } else {
-      _this__u8e3s4.c1g(cause);
+      _this__u8e3s4.h1h(cause);
     }
   }
   function invokeOnCompletion(_this__u8e3s4, block) {
     _init_properties_ByteWriteChannelOperations_kt__i7slrs();
-    var tmp = _this__u8e3s4.it();
-    tmp.lo(invokeOnCompletion$lambda(block));
+    var tmp = _this__u8e3s4.zt();
+    tmp.cp(invokeOnCompletion$lambda(block));
   }
   function writer_0(_this__u8e3s4, coroutineContext, channel, block) {
     coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_getInstance() : 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));
-    // Inline function 'kotlin.contracts.contract' call
     // Inline function 'io.ktor.utils.io.writer.<anonymous>' call
-    this_0.lo(writer$lambda(channel));
+    this_0.cp(writer$lambda(channel));
     var job = this_0;
     return new WriterJob(channel, job);
   }
@@ -1220,30 +1220,30 @@
     startCoroutineCancellable(_this__u8e3s4, get_NO_CALLBACK());
   }
   function NO_CALLBACK$1() {
-    this.j1j_1 = EmptyCoroutineContext_getInstance();
+    this.o1k_1 = EmptyCoroutineContext_getInstance();
   }
-  protoOf(NO_CALLBACK$1).j9 = function () {
-    return this.j1j_1;
+  protoOf(NO_CALLBACK$1).k9 = function () {
+    return this.o1k_1;
   };
-  protoOf(NO_CALLBACK$1).k9 = function (result) {
+  protoOf(NO_CALLBACK$1).l9 = function (result) {
     return Unit_instance;
   };
-  protoOf(NO_CALLBACK$1).o9 = function (result) {
-    return this.k9(result);
+  protoOf(NO_CALLBACK$1).p9 = function (result) {
+    return this.l9(result);
   };
   function ByteWriteChannel$flushAndClose$ref($boundThis) {
-    this.k1j_1 = $boundThis;
+    this.p1k_1 = $boundThis;
   }
-  protoOf(ByteWriteChannel$flushAndClose$ref).l1j = function ($completion) {
-    return this.k1j_1.b1g($completion);
+  protoOf(ByteWriteChannel$flushAndClose$ref).q1k = function ($completion) {
+    return this.p1k_1.g1h($completion);
   };
-  protoOf(ByteWriteChannel$flushAndClose$ref).sa = function ($completion) {
-    return this.l1j($completion);
+  protoOf(ByteWriteChannel$flushAndClose$ref).bb = function ($completion) {
+    return this.q1k($completion);
   };
   function ByteWriteChannel$flushAndClose$ref_0($boundThis) {
     var i = new ByteWriteChannel$flushAndClose$ref($boundThis);
     var l = function ($completion) {
-      return i.l1j($completion);
+      return i.q1k($completion);
     };
     l.callableName = 'flushAndClose';
     l.$arity = 0;
@@ -1256,74 +1256,74 @@
     };
   }
   function writer$slambda($block, $channel, resultContinuation) {
-    this.u1j_1 = $block;
-    this.v1j_1 = $channel;
+    this.z1k_1 = $block;
+    this.a1l_1 = $channel;
     CoroutineImpl.call(this, resultContinuation);
   }
-  protoOf(writer$slambda).l1k = function ($this$launch, $completion) {
-    var tmp = this.m1k($this$launch, $completion);
-    tmp.f9_1 = Unit_instance;
-    tmp.g9_1 = null;
-    return tmp.l9();
+  protoOf(writer$slambda).u1l = function ($this$launch, $completion) {
+    var tmp = this.v1l($this$launch, $completion);
+    tmp.g9_1 = Unit_instance;
+    tmp.h9_1 = null;
+    return tmp.m9();
   };
-  protoOf(writer$slambda).v9 = function (p1, $completion) {
-    return this.l1k((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+  protoOf(writer$slambda).w9 = function (p1, $completion) {
+    return this.u1l((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
   };
-  protoOf(writer$slambda).l9 = function () {
-    var suspendResult = this.f9_1;
+  protoOf(writer$slambda).m9 = function () {
+    var suspendResult = this.g9_1;
     $sm: do
       try {
-        var tmp = this.d9_1;
+        var tmp = this.e9_1;
         switch (tmp) {
           case 0:
-            this.e9_1 = 14;
-            this.x1j_1 = Job(get_job(this.w1j_1.jn()));
-            this.d9_1 = 1;
+            this.f9_1 = 14;
+            this.c1l_1 = Job(get_job(this.b1l_1.ao()));
+            this.e9_1 = 1;
             continue $sm;
           case 1:
-            this.e9_1 = 4;
-            this.e9_1 = 3;
-            this.d9_1 = 2;
-            suspendResult = this.u1j_1(new WriterScope(this.v1j_1, this.w1j_1.jn().bh(this.x1j_1)), this);
+            this.f9_1 = 4;
+            this.f9_1 = 3;
+            this.e9_1 = 2;
+            suspendResult = this.z1k_1(new WriterScope(this.a1l_1, this.b1l_1.ao().jh(this.c1l_1)), this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 2:
-            this.x1j_1.eu();
+            this.c1l_1.vu();
             var tmp_0 = this;
             var tmp_1;
-            if (get_job(this.w1j_1.jn()).fo()) {
-              this.v1j_1.c1g(get_job(this.w1j_1.jn()).io());
+            if (get_job(this.b1l_1.ao()).wo()) {
+              this.a1l_1.h1h(get_job(this.b1l_1.ao()).zo());
               tmp_1 = Unit_instance;
             }
 
-            tmp_0.y1j_1 = tmp_1;
-            this.e9_1 = 14;
-            this.d9_1 = 9;
+            tmp_0.d1l_1 = tmp_1;
+            this.f9_1 = 14;
+            this.e9_1 = 9;
             continue $sm;
           case 3:
-            this.e9_1 = 4;
-            var tmp_2 = this.g9_1;
+            this.f9_1 = 4;
+            var tmp_2 = this.h9_1;
             if (tmp_2 instanceof Error) {
-              this.z1j_1 = this.g9_1;
+              this.e1l_1 = this.h9_1;
               var tmp_3 = this;
-              cancel(this.x1j_1, 'Exception thrown while writing to channel', this.z1j_1);
-              this.v1j_1.c1g(this.z1j_1);
-              tmp_3.y1j_1 = Unit_instance;
-              this.e9_1 = 14;
-              this.d9_1 = 9;
+              cancel(this.c1l_1, 'Exception thrown while writing to channel', this.e1l_1);
+              this.a1l_1.h1h(this.e1l_1);
+              tmp_3.d1l_1 = Unit_instance;
+              this.f9_1 = 14;
+              this.e9_1 = 9;
               continue $sm;
             } else {
-              throw this.g9_1;
+              throw this.h9_1;
             }
 
           case 4:
-            this.e9_1 = 14;
-            this.a1k_1 = this.g9_1;
-            this.d9_1 = 5;
-            suspendResult = this.x1j_1.fu(this);
+            this.f9_1 = 14;
+            this.f1l_1 = this.h9_1;
+            this.e9_1 = 5;
+            suspendResult = this.c1l_1.wu(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -1331,14 +1331,16 @@
             continue $sm;
           case 5:
             var tmp_4 = this;
-            tmp_4.b1k_1 = this.w1j_1;
-            this.e9_1 = 7;
+            tmp_4.g1l_1 = this.b1l_1;
+            this.h1l_1 = this.g1l_1;
+            this.f9_1 = 7;
             var tmp_5 = this;
-            tmp_5.d1k_1 = Companion_instance;
+            tmp_5.j1l_1 = Companion_instance;
             var tmp_6 = this;
-            tmp_6.e1k_1 = this.b1k_1;
-            this.d9_1 = 6;
-            suspendResult = this.v1j_1.b1g(this);
+            tmp_6.k1l_1 = this.h1l_1;
+            this.l1l_1 = this.k1l_1;
+            this.e9_1 = 6;
+            suspendResult = this.a1l_1.g1h(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
@@ -1346,96 +1348,103 @@
             continue $sm;
           case 6:
             var tmp_7 = this;
-            tmp_7.f1k_1 = Unit_instance;
-            this.c1k_1 = _Result___init__impl__xyqfz8(this.f1k_1);
-            this.e9_1 = 14;
-            this.d9_1 = 8;
+            tmp_7.m1l_1 = Unit_instance;
+            var tmp_8 = this;
+            this.j1l_1;
+            var value = this.m1l_1;
+            tmp_8.i1l_1 = _Result___init__impl__xyqfz8(value);
+            this.f9_1 = 14;
+            this.e9_1 = 8;
             continue $sm;
           case 7:
-            this.e9_1 = 14;
-            var tmp_8 = this.g9_1;
-            if (tmp_8 instanceof Error) {
-              this.g1k_1 = this.g9_1;
-              var tmp_9 = this;
-              var exception = this.g1k_1;
-              tmp_9.c1k_1 = _Result___init__impl__xyqfz8(createFailure(exception));
-              this.d9_1 = 8;
+            this.f9_1 = 14;
+            var tmp_9 = this.h9_1;
+            if (tmp_9 instanceof Error) {
+              this.n1l_1 = this.h9_1;
+              var tmp_10 = this;
+              var exception = this.n1l_1;
+              tmp_10.i1l_1 = _Result___init__impl__xyqfz8(createFailure(exception));
+              this.e9_1 = 8;
               continue $sm;
             } else {
-              throw this.g9_1;
+              throw this.h9_1;
             }
 
           case 8:
-            this.e9_1 = 14;
-            throw this.a1k_1;
+            this.f9_1 = 14;
+            throw this.f1l_1;
           case 9:
-            this.e9_1 = 14;
-            this.d9_1 = 10;
-            suspendResult = this.x1j_1.fu(this);
+            this.f9_1 = 14;
+            this.e9_1 = 10;
+            suspendResult = this.c1l_1.wu(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 10:
-            var tmp_10 = this;
-            tmp_10.h1k_1 = this.w1j_1;
-            this.e9_1 = 12;
             var tmp_11 = this;
-            tmp_11.j1k_1 = Companion_instance;
+            tmp_11.o1l_1 = this.b1l_1;
+            this.p1l_1 = this.o1l_1;
+            this.f9_1 = 12;
             var tmp_12 = this;
-            tmp_12.k1k_1 = this.h1k_1;
-            this.d9_1 = 11;
-            suspendResult = this.v1j_1.b1g(this);
+            tmp_12.r1l_1 = Companion_instance;
+            var tmp_13 = this;
+            tmp_13.s1l_1 = this.p1l_1;
+            this.t1l_1 = this.s1l_1;
+            this.e9_1 = 11;
+            suspendResult = this.a1l_1.g1h(this);
             if (suspendResult === get_COROUTINE_SUSPENDED()) {
               return suspendResult;
             }
 
             continue $sm;
           case 11:
-            this.i1k_1 = _Result___init__impl__xyqfz8(Unit_instance);
-            this.e9_1 = 14;
-            this.d9_1 = 13;
+            var tmp_14 = this;
+            this.r1l_1;
+            tmp_14.q1l_1 = _Result___init__impl__xyqfz8(Unit_instance);
+            this.f9_1 = 14;
+            this.e9_1 = 13;
             continue $sm;
           case 12:
-            this.e9_1 = 14;
-            var tmp_13 = this.g9_1;
-            if (tmp_13 instanceof Error) {
-              var e = this.g9_1;
-              var tmp_14 = this;
-              tmp_14.i1k_1 = _Result___init__impl__xyqfz8(createFailure(e));
-              this.d9_1 = 13;
+            this.f9_1 = 14;
+            var tmp_15 = this.h9_1;
+            if (tmp_15 instanceof Error) {
+              var e = this.h9_1;
+              var tmp_16 = this;
+              tmp_16.q1l_1 = _Result___init__impl__xyqfz8(createFailure(e));
+              this.e9_1 = 13;
               continue $sm;
             } else {
-              throw this.g9_1;
+              throw this.h9_1;
             }
 
           case 13:
-            this.e9_1 = 14;
+            this.f9_1 = 14;
             return Unit_instance;
           case 14:
-            throw this.g9_1;
+            throw this.h9_1;
         }
       } catch ($p) {
         var e_0 = $p;
-        if (this.e9_1 === 14) {
+        if (this.f9_1 === 14) {
           throw e_0;
         } else {
-          this.d9_1 = this.e9_1;
-          this.g9_1 = e_0;
+          this.e9_1 = this.f9_1;
+          this.h9_1 = e_0;
         }
       }
      while (true);
   };
-  protoOf(writer$slambda).m1k = function ($this$launch, completion) {
-    var i = new writer$slambda(this.u1j_1, this.v1j_1, completion);
-    i.w1j_1 = $this$launch;
+  protoOf(writer$slambda).v1l = function ($this$launch, completion) {
+    var i = new writer$slambda(this.z1k_1, this.a1l_1, completion);
+    i.b1l_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.l1k($this$launch, $completion);
+      return i.u1l($this$launch, $completion);
     };
     l.$arity = 1;
     return l;
@@ -1443,8 +1452,8 @@
   function writer$lambda($channel) {
     return function (it) {
       var tmp;
-      if (!(it == null) && !$channel.w1f()) {
-        $channel.c1g(it);
+      if (!(it == null) && !$channel.b1h()) {
+        $channel.h1h(it);
         tmp = Unit_instance;
       }
       return Unit_instance;
@@ -1471,7 +1480,7 @@
       if (origin instanceof CancellationException) {
         var tmp_1;
         if (isInterface(origin, CopyableThrowable)) {
-          tmp_1 = origin.nu();
+          tmp_1 = origin.ev();
         } else {
           var tmp0_elvis_lhs = origin.message;
           tmp_1 = CancellationException_init_$Create$(tmp0_elvis_lhs == null ? 'Channel was cancelled' : tmp0_elvis_lhs, origin);
@@ -1485,37 +1494,37 @@
           tmp_2 = false;
         }
         if (tmp_2) {
-          tmp_0 = origin.nu();
+          tmp_0 = origin.ev();
         } else {
           var tmp1_elvis_lhs = origin.message;
           tmp_0 = IOException_init_$Create$_0(tmp1_elvis_lhs == null ? 'Channel was closed' : tmp1_elvis_lhs, origin);
         }
       }
     }
-    tmp.x1f_1 = tmp_0;
+    tmp.c1h_1 = tmp_0;
   }
-  protoOf(CloseToken).u9 = function () {
+  protoOf(CloseToken).v9 = function () {
     var tmp;
-    if (this.x1f_1 == null) {
+    if (this.c1h_1 == null) {
       tmp = null;
     } else {
-      var tmp_0 = this.x1f_1;
+      var tmp_0 = this.c1h_1;
       if (tmp_0 instanceof IOException) {
         var tmp_1;
-        var tmp_2 = this.x1f_1;
+        var tmp_2 = this.c1h_1;
         if (isInterface(tmp_2, CopyableThrowable)) {
-          tmp_1 = this.x1f_1.nu();
+          tmp_1 = this.c1h_1.ev();
         } else {
-          tmp_1 = IOException_init_$Create$_0(this.x1f_1.message, this.x1f_1);
+          tmp_1 = IOException_init_$Create$_0(this.c1h_1.message, this.c1h_1);
         }
         tmp = tmp_1;
       } else {
-        var tmp_3 = this.x1f_1;
+        var tmp_3 = this.c1h_1;
         if (!(tmp_3 == null) ? isInterface(tmp_3, CopyableThrowable) : false) {
-          var tmp0_elvis_lhs = this.x1f_1.nu();
-          tmp = tmp0_elvis_lhs == null ? CancellationException_init_$Create$(this.x1f_1.message, this.x1f_1) : tmp0_elvis_lhs;
+          var tmp0_elvis_lhs = this.c1h_1.ev();
+          tmp = tmp0_elvis_lhs == null ? CancellationException_init_$Create$(this.c1h_1.message, this.c1h_1) : tmp0_elvis_lhs;
         } else {
-          tmp = CancellationException_init_$Create$(this.x1f_1.message, this.x1f_1);
+          tmp = CancellationException_init_$Create$(this.c1h_1.message, this.c1h_1);
         }
       }
     }
@@ -1532,57 +1541,53 @@
     return readString(_this__u8e3s4);
   }
   function SourceByteReadChannel(source) {
-    this.n1k_1 = source;
-    this.o1k_1 = null;
+    this.w1l_1 = source;
+    this.x1l_1 = null;
   }
-  protoOf(SourceByteReadChannel).u1f = function () {
-    var tmp0_safe_receiver = this.o1k_1;
-    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u9();
+  protoOf(SourceByteReadChannel).z1g = function () {
+    var tmp0_safe_receiver = this.x1l_1;
+    return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.v9();
   };
-  protoOf(SourceByteReadChannel).y1f = function () {
-    return this.n1k_1.u1a();
+  protoOf(SourceByteReadChannel).d1h = function () {
+    return this.w1l_1.v1b();
   };
-  protoOf(SourceByteReadChannel).t1f = function () {
-    var tmp0_safe_receiver = this.u1f();
+  protoOf(SourceByteReadChannel).y1g = function () {
+    var tmp0_safe_receiver = this.z1g();
     if (tmp0_safe_receiver == null)
       null;
     else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       throw tmp0_safe_receiver;
     }
-    return this.n1k_1;
+    return this.w1l_1;
   };
-  protoOf(SourceByteReadChannel).z1f = function (min, $completion) {
-    var tmp0_safe_receiver = this.u1f();
+  protoOf(SourceByteReadChannel).e1h = function (min, $completion) {
+    var tmp0_safe_receiver = this.z1g();
     if (tmp0_safe_receiver == null)
       null;
     else {
       // Inline function 'kotlin.let' call
-      // Inline function 'kotlin.contracts.contract' call
       throw tmp0_safe_receiver;
     }
-    return get_remaining(this.n1k_1).e1(toLong(min)) >= 0;
+    return get_remaining(this.w1l_1).e1(toLong(min)) >= 0;
   };
-  protoOf(SourceByteReadChannel).c1g = function (cause) {
-    if (!(this.o1k_1 == null))
+  protoOf(SourceByteReadChannel).h1h = function (cause) {
+    if (!(this.x1l_1 == null))
       return Unit_instance;
-    this.n1k_1.p1c();
+    this.w1l_1.q1d();
     var tmp = this;
     var tmp1_elvis_lhs = cause == null ? null : cause.message;
-    tmp.o1k_1 = new CloseToken(IOException_init_$Create$_0(tmp1_elvis_lhs == null ? 'Channel was cancelled' : tmp1_elvis_lhs, cause));
+    tmp.x1l_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;
-    // Inline function 'kotlin.text.buildString' call
+    var tmp0 = toLong(max);
     // Inline function 'kotlin.comparisons.minOf' call
-    var a = toLong(max);
-    var b = input.t1a().s();
-    var capacity = (a.e1(b) <= 0 ? a : b).j1();
-    // Inline function 'kotlin.contracts.contract' call
+    var b = input.u1b().s();
+    // Inline function 'kotlin.text.buildString' call
+    var capacity = (tmp0.e1(b) <= 0 ? tmp0 : b).j1();
     // Inline function 'kotlin.apply' call
     var this_0 = StringBuilder_init_$Create$(capacity);
-    // Inline function 'kotlin.contracts.contract' call
     // Inline function 'io.ktor.utils.io.charsets.decode.<anonymous>' call
     decode_0(_this__u8e3s4, input, this_0, max);
     return this_0.toString();
@@ -1594,13 +1599,8 @@
     $l$loop: while (true) {
       var rc = encodeImpl(_this__u8e3s4, input, start, toIndex, destination);
       // Inline function 'kotlin.check' call
-      // Inline function 'kotlin.contracts.contract' call
-      // Inline function 'kotlin.check' call
-      // Inline function 'kotlin.contracts.contract' call
       if (!(rc >= 0)) {
-        // Inline function 'kotlin.check.<anonymous>' call
-        var message = 'Check failed.';
-        throw IllegalStateException_init_$Create$(toString_0(message));
+        throw IllegalStateException_init_$Create$('Check failed.');
       }
       start = start + rc | 0;
       if (start >= toIndex)
@@ -1617,7 +1617,7 @@
     return builder;
   }
   function canRead(_this__u8e3s4) {
-    return !_this__u8e3s4.u1a();
+    return !_this__u8e3s4.v1b();
   }
   function readBytes(_this__u8e3s4, count) {
     count = count === VOID ? _this__u8e3s4.s().j1() : count;
@@ -1627,37 +1627,37 @@
     return new Buffer();
   }
   function writePacket_0(_this__u8e3s4, packet) {
-    _this__u8e3s4.k1c(packet);
+    _this__u8e3s4.l1d(packet);
   }
   function build(_this__u8e3s4) {
-    return _this__u8e3s4.t1a();
+    return _this__u8e3s4.u1b();
   }
   function get_size(_this__u8e3s4) {
-    return _this__u8e3s4.t1a().s().j1();
+    return _this__u8e3s4.u1b().s().j1();
   }
   function writeFully_0(_this__u8e3s4, buffer, offset, length) {
     offset = offset === VOID ? 0 : offset;
     length = length === VOID ? buffer.length - offset | 0 : length;
-    _this__u8e3s4.c1c(buffer, offset, offset + length | 0);
+    _this__u8e3s4.d1d(buffer, offset, offset + length | 0);
   }
   var ByteReadPacketEmpty;
   function get_remaining(_this__u8e3s4) {
     _init_properties_ByteReadPacket_kt__28475y();
-    return _this__u8e3s4.t1a().s();
+    return _this__u8e3s4.u1b().s();
   }
   function discard(_this__u8e3s4, count) {
     count = count === VOID ? new Long(-1, 2147483647) : count;
     _init_properties_ByteReadPacket_kt__28475y();
-    _this__u8e3s4.w1a(count);
+    _this__u8e3s4.x1b(count);
     // Inline function 'kotlin.comparisons.minOf' call
     var b = get_remaining(_this__u8e3s4);
     var countToDiscard = count.e1(b) <= 0 ? count : b;
-    _this__u8e3s4.t1a().q1b(countToDiscard);
+    _this__u8e3s4.u1b().r1c(countToDiscard);
     return countToDiscard;
   }
   function takeWhile(_this__u8e3s4, block) {
     _init_properties_ByteReadPacket_kt__28475y();
-    while (!_this__u8e3s4.u1a() && block(_this__u8e3s4.t1a())) {
+    while (!_this__u8e3s4.v1b() && block(_this__u8e3s4.u1b())) {
     }
   }
   var properties_initialized_ByteReadPacket_kt_hw4st4;
@@ -1670,37 +1670,37 @@
   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.r1b(buffer, offset, offset + length | 0);
+    var result = _this__u8e3s4.s1c(buffer, offset, offset + length | 0);
     return result === -1 ? 0 : result;
   }
   function readText_0(_this__u8e3s4, charset, max) {
-    charset = charset === VOID ? Charsets_getInstance().p1k_1 : charset;
+    charset = charset === VOID ? Charsets_getInstance().y1l_1 : charset;
     max = max === VOID ? 2147483647 : max;
-    if (charset.equals(Charsets_getInstance().p1k_1)) {
+    if (charset.equals(Charsets_getInstance().y1l_1)) {
       if (max === 2147483647)
         return readString(_this__u8e3s4);
+      var tmp0 = _this__u8e3s4.u1b().s();
       // Inline function 'kotlin.math.min' call
-      var a = _this__u8e3s4.t1a().s();
       var b = toLong(max);
-      var count = a.e1(b) <= 0 ? a : b;
+      var count = tmp0.e1(b) <= 0 ? tmp0 : b;
       return readString_0(_this__u8e3s4, count);
     }
-    return decode(charset.s1k(), _this__u8e3s4, max);
+    return decode(charset.b1m(), _this__u8e3s4, max);
   }
   function toByteArray_0(_this__u8e3s4, charset) {
-    charset = charset === VOID ? Charsets_getInstance().p1k_1 : charset;
-    if (charset.equals(Charsets_getInstance().p1k_1))
+    charset = charset === VOID ? Charsets_getInstance().y1l_1 : charset;
+    if (charset.equals(Charsets_getInstance().y1l_1))
       return encodeToByteArray(_this__u8e3s4, VOID, VOID, true);
-    return encodeToByteArray_0(charset.t1k(), _this__u8e3s4, 0, _this__u8e3s4.length);
+    return encodeToByteArray_0(charset.c1m(), _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().p1k_1 : charset;
-    if (charset === Charsets_getInstance().p1k_1) {
+    charset = charset === VOID ? Charsets_getInstance().y1l_1 : charset;
+    if (charset === Charsets_getInstance().y1l_1) {
       return writeString(_this__u8e3s4, toString_0(text), fromIndex, toIndex);
     }
-    encodeToImpl(charset.t1k(), _this__u8e3s4, text, fromIndex, toIndex);
+    encodeToImpl(charset.c1m(), _this__u8e3s4, text, fromIndex, toIndex);
   }
   function get_ByteArrayPool() {
     _init_properties_ByteArrayPool_kt__kfi3uj();
@@ -1710,7 +1710,7 @@
   function ByteArrayPool$1() {
     DefaultPool.call(this, 128);
   }
-  protoOf(ByteArrayPool$1).x1k = function () {
+  protoOf(ByteArrayPool$1).g1m = function () {
     return new Int8Array(4096);
   };
   var properties_initialized_ByteArrayPool_kt_td6pfh;
@@ -1722,13 +1722,13 @@
   }
   function Companion_1() {
   }
-  protoOf(Companion_1).g1l = function (name) {
+  protoOf(Companion_1).p1m = function (name) {
     switch (name) {
       case 'UTF-8':
       case 'utf-8':
       case 'UTF8':
       case 'utf8':
-        return Charsets_getInstance().p1k_1;
+        return Charsets_getInstance().y1l_1;
     }
     var tmp;
     var tmp_0;
@@ -1741,8 +1741,6 @@
       default:
         // Inline function 'kotlin.let' call
 
-        // Inline function 'kotlin.contracts.contract' call
-
         // Inline function 'io.ktor.utils.io.charsets.Companion.forName.<anonymous>' call
 
         var it = replace(name, _Char___init__impl__6a9atx(95), _Char___init__impl__6a9atx(45));
@@ -1769,11 +1767,11 @@
       tmp = name === 'Latin1';
     }
     if (tmp) {
-      return Charsets_getInstance().q1k_1;
+      return Charsets_getInstance().z1l_1;
     }
     throw IllegalArgumentException_init_$Create$('Charset ' + name + ' is not supported');
   };
-  protoOf(Companion_1).h1l = function (charset) {
+  protoOf(Companion_1).q1m = function (charset) {
     var tmp;
     switch (charset) {
       case 'UTF-8':
@@ -1793,8 +1791,6 @@
           default:
             // Inline function 'kotlin.let' call
 
-            // Inline function 'kotlin.contracts.contract' call
-
             // Inline function 'io.ktor.utils.io.charsets.Companion.isSupported.<anonymous>' call
 
             var it = replace(charset, _Char___init__impl__6a9atx(95), _Char___init__impl__6a9atx(45));
@@ -1832,7 +1828,7 @@
     return Companion_instance_2;
   }
   function Charset(_name) {
-    this.r1k_1 = _name;
+    this.a1m_1 = _name;
   }
   protoOf(Charset).equals = function (other) {
     if (this === other)
@@ -1841,21 +1837,21 @@
       return false;
     if (!(other instanceof Charset))
       THROW_CCE();
-    return this.r1k_1 === other.r1k_1;
+    return this.a1m_1 === other.a1m_1;
   };
   protoOf(Charset).hashCode = function () {
-    return getStringHashCode(this.r1k_1);
+    return getStringHashCode(this.a1m_1);
   };
   protoOf(Charset).toString = function () {
-    return this.r1k_1;
+    return this.a1m_1;
   };
   function get_name(_this__u8e3s4) {
-    return _this__u8e3s4.r1k_1;
+    return _this__u8e3s4.a1m_1;
   }
   function Charsets() {
     Charsets_instance = this;
-    this.p1k_1 = new CharsetImpl('UTF-8');
-    this.q1k_1 = new CharsetImpl('ISO-8859-1');
+    this.y1l_1 = new CharsetImpl('UTF-8');
+    this.z1l_1 = new CharsetImpl('ISO-8859-1');
   }
   var Charsets_instance;
   function Charsets_getInstance() {
@@ -1868,29 +1864,29 @@
     captureStack(this, MalformedInputException);
   }
   function CharsetDecoder(_charset) {
-    this.i1l_1 = _charset;
+    this.r1m_1 = _charset;
   }
   function CharsetEncoder(_charset) {
-    this.j1l_1 = _charset;
+    this.s1m_1 = _charset;
   }
   function CharsetImpl(name) {
     Charset.call(this, name);
   }
-  protoOf(CharsetImpl).t1k = function () {
+  protoOf(CharsetImpl).c1m = function () {
     return new CharsetEncoderImpl(this);
   };
-  protoOf(CharsetImpl).s1k = function () {
+  protoOf(CharsetImpl).b1m = function () {
     return new CharsetDecoderImpl(this);
   };
   function CharsetEncoderImpl(charset) {
     CharsetEncoder.call(this, charset);
-    this.m1l_1 = charset;
+    this.v1m_1 = charset;
   }
   protoOf(CharsetEncoderImpl).toString = function () {
-    return 'CharsetEncoderImpl(charset=' + this.m1l_1.toString() + ')';
+    return 'CharsetEncoderImpl(charset=' + this.v1m_1.toString() + ')';
   };
   protoOf(CharsetEncoderImpl).hashCode = function () {
-    return this.m1l_1.hashCode();
+    return this.v1m_1.hashCode();
   };
   protoOf(CharsetEncoderImpl).equals = function (other) {
     if (this === other)
@@ -1898,19 +1894,19 @@
     if (!(other instanceof CharsetEncoderImpl))
       return false;
     var tmp0_other_with_cast = other instanceof CharsetEncoderImpl ? other : THROW_CCE();
-    if (!this.m1l_1.equals(tmp0_other_with_cast.m1l_1))
+    if (!this.v1m_1.equals(tmp0_other_with_cast.v1m_1))
       return false;
     return true;
   };
   function CharsetDecoderImpl(charset) {
     CharsetDecoder.call(this, charset);
-    this.o1l_1 = charset;
+    this.x1m_1 = charset;
   }
   protoOf(CharsetDecoderImpl).toString = function () {
-    return 'CharsetDecoderImpl(charset=' + this.o1l_1.toString() + ')';
+    return 'CharsetDecoderImpl(charset=' + this.x1m_1.toString() + ')';
   };
   protoOf(CharsetDecoderImpl).hashCode = function () {
-    return this.o1l_1.hashCode();
+    return this.x1m_1.hashCode();
   };
   protoOf(CharsetDecoderImpl).equals = function (other) {
     if (this === other)
@@ -1918,7 +1914,7 @@
     if (!(other instanceof CharsetDecoderImpl))
       return false;
     var tmp0_other_with_cast = other instanceof CharsetDecoderImpl ? other : THROW_CCE();
-    if (!this.o1l_1.equals(tmp0_other_with_cast.o1l_1))
+    if (!this.x1m_1.equals(tmp0_other_with_cast.x1m_1))
       return false;
     return true;
   };
@@ -1929,15 +1925,15 @@
   }
   function decode_0(_this__u8e3s4, input, dst, max) {
     var decoder = Decoder(get_name(get_charset(_this__u8e3s4)), true);
+    var tmp0 = input.u1b().s();
     // Inline function 'kotlin.comparisons.minOf' call
-    var a = input.t1a().s();
     var b = toLong(max);
-    var count = a.e1(b) <= 0 ? a : b;
+    var count = tmp0.e1(b) <= 0 ? tmp0 : b;
     var tmp = readByteArray(input, count.j1());
     var array = tmp instanceof Int8Array ? tmp : THROW_CCE();
     var tmp_0;
     try {
-      tmp_0 = decoder.p1l(array);
+      tmp_0 = decoder.y1m(array);
     } catch ($p) {
       var tmp_1;
       if ($p instanceof Error) {
@@ -1968,24 +1964,21 @@
     return readByteArray_0(dst);
   }
   function get_charset(_this__u8e3s4) {
-    return _this__u8e3s4.i1l_1;
+    return _this__u8e3s4.r1m_1;
   }
   function encodeImpl(_this__u8e3s4, input, fromIndex, toIndex, dst) {
     // Inline function 'kotlin.require' call
-    // Inline function 'kotlin.contracts.contract' call
     // Inline function 'kotlin.require' call
-    // Inline function 'kotlin.contracts.contract' call
     if (!(fromIndex <= toIndex)) {
       // Inline function 'kotlin.require.<anonymous>' call
       var message = 'Failed requirement.';
       throw IllegalArgumentException_init_$Create$(toString_0(message));
     }
-    if (get_charset_0(_this__u8e3s4).equals(Charsets_getInstance().q1k_1)) {
+    if (get_charset_0(_this__u8e3s4).equals(Charsets_getInstance().z1l_1)) {
       return encodeISO88591(input, fromIndex, toIndex, dst);
     }
     // Inline function 'kotlin.require' call
-    // Inline function 'kotlin.contracts.contract' call
-    if (!(get_charset_0(_this__u8e3s4) === Charsets_getInstance().p1k_1)) {
+    if (!(get_charset_0(_this__u8e3s4) === Charsets_getInstance().y1l_1)) {
       // Inline function 'io.ktor.utils.io.charsets.encodeImpl.<anonymous>' call
       var message_0 = 'Only UTF-8 encoding is supported in JS';
       throw IllegalArgumentException_init_$Create$(toString_0(message_0));
@@ -1996,17 +1989,17 @@
     var result = encoder.encode(tmp$ret$2);
     // Inline function 'kotlin.js.unsafeCast' call
     // Inline function 'kotlin.js.asDynamic' call
-    dst.f1c(result);
+    dst.g1d(result);
     return result.length;
   }
   function get_charset_0(_this__u8e3s4) {
-    return _this__u8e3s4.j1l_1;
+    return _this__u8e3s4.s1m_1;
   }
   function forName(_this__u8e3s4, name) {
-    return Companion_instance_2.g1l(name);
+    return Companion_instance_2.p1m(name);
   }
   function isSupported(_this__u8e3s4, name) {
-    return Companion_instance_2.h1l(name);
+    return Companion_instance_2.q1m(name);
   }
   function Decoder(encoding, fatal) {
     fatal = fatal === VOID ? true : fatal;
@@ -2032,19 +2025,18 @@
     fatal = fatal === VOID ? false : fatal;
     // Inline function 'kotlin.apply' call
     var this_0 = new Object();
-    // Inline function 'kotlin.contracts.contract' call
     // Inline function 'io.ktor.utils.io.charsets.textDecoderOptions.<anonymous>' call
-    // Inline function 'kotlin.with' call
     // Inline function 'kotlin.js.asDynamic' call
-    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.with' call
+    // Inline function 'io.ktor.utils.io.charsets.textDecoderOptions.<anonymous>.<anonymous>' call
     this_0.fatal = fatal;
     return this_0;
   }
   function toKtor$1($this_toKtor) {
-    this.q1l_1 = $this_toKtor;
+    this.z1m_1 = $this_toKtor;
   }
-  protoOf(toKtor$1).p1l = function (buffer) {
-    return this.q1l_1.decode(buffer);
+  protoOf(toKtor$1).y1m = function (buffer) {
+    return this.z1m_1.decode(buffer);
   };
   function get_ENCODING_ALIASES() {
     _init_properties_TextDecoderFallback_js_kt__an7r6m();
@@ -2057,20 +2049,19 @@
   }
   var REPLACEMENT;
   function TextDecoderFallback(encoding, fatal) {
-    this.r1l_1 = fatal;
-    // Inline function 'kotlin.text.lowercase' call
+    this.a1n_1 = fatal;
     // Inline function 'kotlin.text.trim' call
+    // Inline function 'kotlin.text.lowercase' call
     // Inline function 'kotlin.js.asDynamic' call
     var requestedEncoding = toString_0(trim(isCharSequence(encoding) ? encoding : THROW_CCE())).toLowerCase();
     // Inline function 'kotlin.check' call
-    // Inline function 'kotlin.contracts.contract' call
     if (!get_ENCODING_ALIASES().x1(requestedEncoding)) {
       // Inline function 'io.ktor.utils.io.charsets.TextDecoderFallback.<anonymous>' call
       var message = encoding + ' is not supported.';
       throw IllegalStateException_init_$Create$(toString_0(message));
     }
   }
-  protoOf(TextDecoderFallback).p1l = function (buffer) {
+  protoOf(TextDecoderFallback).y1m = function (buffer) {
     // Inline function 'io.ktor.utils.io.core.buildPacket' call
     var builder = new Buffer();
     // Inline function 'io.ktor.utils.io.charsets.TextDecoderFallback.decode.<anonymous>' call
@@ -2087,8 +2078,7 @@
         var point = toCodePoint(byte);
         if (point < 0) {
           // Inline function 'kotlin.check' call
-          // Inline function 'kotlin.contracts.contract' call
-          if (!!this.r1l_1) {
+          if (!!this.a1n_1) {
             // Inline function 'io.ktor.utils.io.charsets.TextDecoderFallback.decode.<anonymous>.<anonymous>' call
             var message = 'Invalid character: ' + point;
             throw IllegalStateException_init_$Create$(toString_0(message));
@@ -2097,9 +2087,9 @@
           continue $l$loop;
         }
         if (point > 255) {
-          builder.l1c(toByte(point >> 8));
+          builder.m1d(toByte(point >> 8));
         }
-        builder.l1c(toByte(point & 255));
+        builder.m1d(toByte(point & 255));
       }
        while (inductionVariable < last);
     return decodeToString(readByteArray_0(builder));
@@ -2139,7 +2129,7 @@
         if (character > 255) {
           failedToMapError(character);
         }
-        dst.l1c(toByte(character));
+        dst.m1d(toByte(character));
       }
        while (inductionVariable < toIndex);
     return toIndex - fromIndex | 0;
@@ -2161,48 +2151,48 @@
     }
   }
   function DefaultPool(capacity) {
-    this.y1k_1 = capacity;
+    this.h1m_1 = capacity;
     var tmp = this;
     // Inline function 'kotlin.arrayOfNulls' call
-    var size = this.y1k_1;
-    tmp.z1k_1 = fillArrayVal(Array(size), null);
-    this.a1l_1 = 0;
+    var size = this.h1m_1;
+    tmp.i1m_1 = fillArrayVal(Array(size), null);
+    this.j1m_1 = 0;
   }
-  protoOf(DefaultPool).b1l = function (instance) {
+  protoOf(DefaultPool).k1m = function (instance) {
   };
-  protoOf(DefaultPool).c1l = function (instance) {
+  protoOf(DefaultPool).l1m = function (instance) {
     return instance;
   };
-  protoOf(DefaultPool).d1l = function (instance) {
+  protoOf(DefaultPool).m1m = function (instance) {
   };
-  protoOf(DefaultPool).e1l = function () {
-    if (this.a1l_1 === 0)
-      return this.x1k();
-    this.a1l_1 = this.a1l_1 - 1 | 0;
-    var idx = this.a1l_1;
-    var tmp = this.z1k_1[idx];
+  protoOf(DefaultPool).n1m = function () {
+    if (this.j1m_1 === 0)
+      return this.g1m();
+    this.j1m_1 = this.j1m_1 - 1 | 0;
+    var idx = this.j1m_1;
+    var tmp = this.i1m_1[idx];
     var instance = !(tmp == null) ? tmp : THROW_CCE();
-    this.z1k_1[idx] = null;
-    return this.c1l(instance);
+    this.i1m_1[idx] = null;
+    return this.l1m(instance);
   };
-  protoOf(DefaultPool).f1l = function (instance) {
-    this.d1l(instance);
-    if (this.a1l_1 === this.y1k_1) {
-      this.b1l(instance);
+  protoOf(DefaultPool).o1m = function (instance) {
+    this.m1m(instance);
+    if (this.j1m_1 === this.h1m_1) {
+      this.k1m(instance);
     } else {
-      var _unary__edvuaz = this.a1l_1;
-      this.a1l_1 = _unary__edvuaz + 1 | 0;
-      this.z1k_1[_unary__edvuaz] = instance;
+      var _unary__edvuaz = this.j1m_1;
+      this.j1m_1 = _unary__edvuaz + 1 | 0;
+      this.i1m_1[_unary__edvuaz] = instance;
     }
   };
   //region block: post-declaration
-  protoOf(Read).x1d = resume;
-  protoOf(Read).y1d = resume_0;
-  protoOf(Write).x1d = resume;
-  protoOf(Write).y1d = resume_0;
-  protoOf(ByteChannel).a1g = awaitContent$default;
-  protoOf(ByteReadChannel$Companion$Empty$1).a1g = awaitContent$default;
-  protoOf(SourceByteReadChannel).a1g = awaitContent$default;
+  protoOf(Read).y1e = resume;
+  protoOf(Read).z1e = resume_0;
+  protoOf(Write).y1e = resume;
+  protoOf(Write).z1e = resume_0;
+  protoOf(ByteChannel).f1h = awaitContent$default;
+  protoOf(ByteReadChannel$Companion$Empty$1).f1h = awaitContent$default;
+  protoOf(SourceByteReadChannel).f1h = awaitContent$default;
   //endregion
   //region block: init
   Empty_instance = new Empty();
@@ -2251,5 +2241,3 @@
   //endregion
   return _;
 }(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./kotlinx-coroutines-core.js'), require('./kotlinx-io-kotlinx-io-core.js'), require('./kotlinx-atomicfu.js')));
-
-//# sourceMappingURL=ktor-ktor-io.js.map