@continuous-excellence/coupling-cli 1.1.498 → 1.1.500

package/kotlin/okio-parent-okio/okio/Buffer.mjs

@@ -5,7 +5,7 @@ import {
   AssertionError3yq7q0knw9m5 as AssertionError,
 } from '../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
 import { toString1pkumu07cwy4m as toString } from '../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
-import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Unit_instancev9v8hjid95df as Unit_instance } from '../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
 import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
 import { VOID3gxj6tk5isa35 as VOID } from '../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
 import {
@@ -23,15 +23,15 @@ import {
   ensureNotNull1e947j3ixpazm as ensureNotNull,
   THROW_CCE2g6jy02ryeudk as THROW_CCE,
 } from '../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
-import { SegmentPool_instance26x4wee5nyx6a as SegmentPool_instance } from './SegmentPool.mjs';
+import { SegmentPool_instance23prvj6kllmmf as SegmentPool_instance } from './SegmentPool.mjs';
 import {
   ByteString2qc03wzjsovk as ByteString,
-  Companion_getInstance28gds36m4006o as Companion_getInstance,
+  Companion_getInstance2g1g1maz1t653 as Companion_getInstance,
 } from './ByteString.mjs';
 import { commonToUtf8Stringyih6e1qg1yoo as commonToUtf8String } from './internal/-Utf8.mjs';
 import {
-  _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
-  Char__toInt_impl_vasixd3jl92hthlhyn7 as Char__toInt_impl_vasixd,
+  _Char___init__impl__6a9atx2gndcvjvc5pke as _Char___init__impl__6a9atx,
+  Char__toInt_impl_vasixdnyockrdnmht5 as Char__toInt_impl_vasixd,
 } from '../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
 import { toByte4i43936u611k as toByte } from '../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
 import {
@@ -53,27 +53,27 @@ function UnsafeCursor() {
   if (UnsafeCursorClass === VOID) {
     class $ {
       constructor() {
-        this.q4k_1 = null;
-        this.r4k_1 = false;
-        this.s4k_1 = null;
-        this.t4k_1 = new (Long())(-1, -1);
-        this.u4k_1 = null;
-        this.v4k_1 = -1;
-        this.w4k_1 = -1;
+        this.y4k_1 = null;
+        this.z4k_1 = false;
+        this.a4l_1 = null;
+        this.b4l_1 = new (Long())(-1, -1);
+        this.c4l_1 = null;
+        this.d4l_1 = -1;
+        this.e4l_1 = -1;
       }
-      o6() {
+      j6() {
         // Inline function 'okio.internal.commonClose' call
         // Inline function 'kotlin.check' call
-        if (!!(this.q4k_1 == null)) {
+        if (!!(this.y4k_1 == null)) {
           var message = 'not attached to a buffer';
           throw IllegalStateException().o(toString(message));
         }
-        this.q4k_1 = null;
-        this.s4k_1 = null;
-        this.t4k_1 = new (Long())(-1, -1);
-        this.u4k_1 = null;
-        this.v4k_1 = -1;
-        this.w4k_1 = -1;
+        this.y4k_1 = null;
+        this.a4l_1 = null;
+        this.b4l_1 = new (Long())(-1, -1);
+        this.c4l_1 = null;
+        this.d4l_1 = -1;
+        this.e4l_1 = -1;
       }
     }
     initMetadataForClass($, 'UnsafeCursor', UnsafeCursor);
@@ -86,166 +86,168 @@ function Buffer() {
   if (BufferClass === VOID) {
     class $ {
       constructor() {
-        this.j4i_1 = null;
-        this.k4i_1 = new (Long())(0, 0);
+        this.r4i_1 = null;
+        this.s4i_1 = new (Long())(0, 0);
       }
-      h1p() {
+      c1p() {
         return this;
       }
-      i1p() {
-        return equalsLong(this.k4i_1, new (Long())(0, 0));
+      d1p() {
+        return equalsLong(this.s4i_1, new (Long())(0, 0));
       }
-      j1p(byteCount) {
-        if (compare(this.k4i_1, byteCount) < 0)
-          throw EOFException().a4l(null);
+      e1p(byteCount) {
+        if (compare(this.s4i_1, byteCount) < 0)
+          throw EOFException().i4l(null);
       }
-      k1p(byteCount) {
-        return compare(this.k4i_1, byteCount) >= 0;
+      f1p(byteCount) {
+        return compare(this.s4i_1, byteCount) >= 0;
       }
-      b4l(out, offset, byteCount) {
+      j4l(out, offset, byteCount) {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonCopyTo' call
           var offset_0 = offset;
           var byteCount_0 = byteCount;
-          checkOffsetAndCount(this.k4i_1, offset_0, byteCount_0);
+          checkOffsetAndCount(this.s4i_1, offset_0, byteCount_0);
           if (equalsLong(byteCount_0, new (Long())(0, 0))) {
             tmp$ret$0 = this;
             break $l$block;
           }
-          out.k4i_1 = add(out.k4i_1, byteCount_0);
-          var s = this.j4i_1;
-          while (compare(offset_0, fromInt(ensureNotNull(s).a4j_1 - s.z4i_1 | 0)) >= 0) {
-            offset_0 = subtract(offset_0, fromInt(s.a4j_1 - s.z4i_1 | 0));
-            s = s.d4j_1;
+          out.s4i_1 = add(out.s4i_1, byteCount_0);
+          var s = this.r4i_1;
+          while (compare(offset_0, fromInt(ensureNotNull(s).i4j_1 - s.h4j_1 | 0)) >= 0) {
+            offset_0 = subtract(offset_0, fromInt(s.i4j_1 - s.h4j_1 | 0));
+            s = s.l4j_1;
           }
           while (compare(byteCount_0, new (Long())(0, 0)) > 0) {
-            var copy = ensureNotNull(s).h4j();
-            copy.z4i_1 = copy.z4i_1 + convertToInt(offset_0) | 0;
+            var copy = ensureNotNull(s).p4j();
+            copy.h4j_1 = copy.h4j_1 + convertToInt(offset_0) | 0;
             var tmp = copy;
-            var tmp0 = copy.z4i_1 + convertToInt(byteCount_0) | 0;
+            var tmp0 = copy.h4j_1 + convertToInt(byteCount_0) | 0;
             // Inline function 'kotlin.comparisons.minOf' call
-            var b = copy.a4j_1;
-            tmp.a4j_1 = Math.min(tmp0, b);
-            if (out.j4i_1 == null) {
-              copy.e4j_1 = copy;
-              copy.d4j_1 = copy.e4j_1;
-              out.j4i_1 = copy.d4j_1;
+            var b = copy.i4j_1;
+            tmp.i4j_1 = Math.min(tmp0, b);
+            if (out.r4i_1 == null) {
+              copy.m4j_1 = copy;
+              copy.l4j_1 = copy.m4j_1;
+              out.r4i_1 = copy.l4j_1;
             } else {
-              ensureNotNull(ensureNotNull(out.j4i_1).e4j_1).j4j(copy);
+              ensureNotNull(ensureNotNull(out.r4i_1).m4j_1).r4j(copy);
             }
-            byteCount_0 = subtract(byteCount_0, fromInt(copy.a4j_1 - copy.z4i_1 | 0));
+            byteCount_0 = subtract(byteCount_0, fromInt(copy.i4j_1 - copy.h4j_1 | 0));
             offset_0 = new (Long())(0, 0);
-            s = s.d4j_1;
+            s = s.l4j_1;
           }
           tmp$ret$0 = this;
         }
         return tmp$ret$0;
       }
-      d1q(pos) {
+      y1p(pos) {
         var tmp$ret$0;
-        $l$block_1: {
+        $l$block_3: {
           // Inline function 'okio.internal.commonGet' call
-          checkOffsetAndCount(this.k4i_1, pos, new (Long())(1, 0));
-          // Inline function 'okio.internal.seek' call
-          var tmp0_elvis_lhs = this.j4i_1;
-          var tmp;
-          if (tmp0_elvis_lhs == null) {
-            var offset = new (Long())(-1, -1);
-            tmp$ret$0 = ensureNotNull(null).y4i_1[convertToInt(subtract(add(numberToLong(null.z4i_1), pos), offset))];
-            break $l$block_1;
-          } else {
-            tmp = tmp0_elvis_lhs;
-          }
-          var s = tmp;
-          if (compare(subtract(this.k4i_1, pos), pos) < 0) {
-            var offset_0 = this.k4i_1;
-            while (compare(offset_0, pos) > 0) {
-              s = ensureNotNull(s.e4j_1);
-              offset_0 = subtract(offset_0, fromInt(s.a4j_1 - s.z4i_1 | 0));
+          checkOffsetAndCount(this.s4i_1, pos, new (Long())(1, 0));
+          $l$block_4: {
+            // Inline function 'okio.internal.seek' call
+            var tmp0_elvis_lhs = this.r4i_1;
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var offset = new (Long())(-1, -1);
+              tmp$ret$0 = ensureNotNull(null).g4j_1[convertToInt(subtract(add(numberToLong(null.h4j_1), pos), offset))];
+              break $l$block_3;
+            } else {
+              tmp = tmp0_elvis_lhs;
             }
-            var tmp0 = s;
-            var offset_1 = offset_0;
-            tmp$ret$0 = ensureNotNull(tmp0).y4i_1[convertToInt(subtract(add(numberToLong(tmp0.z4i_1), pos), offset_1))];
-            break $l$block_1;
-          } else {
-            var offset_2 = new (Long())(0, 0);
-            $l$loop: while (true) {
-              var tmp0_0 = offset_2;
-              // Inline function 'kotlin.Long.plus' call
-              var other = s.a4j_1 - s.z4i_1 | 0;
-              var nextOffset = add(tmp0_0, fromInt(other));
-              if (compare(nextOffset, pos) > 0)
-                break $l$loop;
-              s = ensureNotNull(s.d4j_1);
-              offset_2 = nextOffset;
+            var s = tmp;
+            if (compare(subtract(this.s4i_1, pos), pos) < 0) {
+              var offset_0 = this.s4i_1;
+              while (compare(offset_0, pos) > 0) {
+                s = ensureNotNull(s.m4j_1);
+                offset_0 = subtract(offset_0, fromInt(s.i4j_1 - s.h4j_1 | 0));
+              }
+              var tmp0 = s;
+              var offset_1 = offset_0;
+              tmp$ret$0 = ensureNotNull(tmp0).g4j_1[convertToInt(subtract(add(numberToLong(tmp0.h4j_1), pos), offset_1))];
+              break $l$block_3;
+            } else {
+              var offset_2 = new (Long())(0, 0);
+              $l$loop: while (true) {
+                var tmp0_0 = offset_2;
+                // Inline function 'kotlin.Long.plus' call
+                var other = s.i4j_1 - s.h4j_1 | 0;
+                var nextOffset = add(tmp0_0, fromInt(other));
+                if (compare(nextOffset, pos) > 0)
+                  break $l$loop;
+                s = ensureNotNull(s.l4j_1);
+                offset_2 = nextOffset;
+              }
+              var tmp0_1 = s;
+              var offset_3 = offset_2;
+              tmp$ret$0 = ensureNotNull(tmp0_1).g4j_1[convertToInt(subtract(add(numberToLong(tmp0_1.h4j_1), pos), offset_3))];
+              break $l$block_3;
             }
-            var tmp0_1 = s;
-            var offset_3 = offset_2;
-            tmp$ret$0 = ensureNotNull(tmp0_1).y4i_1[convertToInt(subtract(add(numberToLong(tmp0_1.z4i_1), pos), offset_3))];
-            break $l$block_1;
           }
         }
         return tmp$ret$0;
       }
-      c4l() {
+      k4l() {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonCompleteSegmentByteCount' call
-          var result = this.k4i_1;
+          var result = this.s4i_1;
           if (equalsLong(result, new (Long())(0, 0))) {
             tmp$ret$0 = new (Long())(0, 0);
             break $l$block;
           }
-          var tail = ensureNotNull(ensureNotNull(this.j4i_1).e4j_1);
-          if (tail.a4j_1 < 8192 && tail.c4j_1) {
-            result = subtract(result, fromInt(tail.a4j_1 - tail.z4i_1 | 0));
+          var tail = ensureNotNull(ensureNotNull(this.r4i_1).m4j_1);
+          if (tail.i4j_1 < 8192 && tail.k4j_1) {
+            result = subtract(result, fromInt(tail.i4j_1 - tail.h4j_1 | 0));
           }
           tmp$ret$0 = result;
         }
         return tmp$ret$0;
       }
-      l1p() {
+      g1p() {
         // Inline function 'okio.internal.commonReadByte' call
-        if (equalsLong(this.k4i_1, new (Long())(0, 0)))
-          throw EOFException().d4l();
-        var segment = ensureNotNull(this.j4i_1);
-        var pos = segment.z4i_1;
-        var limit = segment.a4j_1;
-        var data = segment.y4i_1;
+        if (equalsLong(this.s4i_1, new (Long())(0, 0)))
+          throw EOFException().l4l();
+        var segment = ensureNotNull(this.r4i_1);
+        var pos = segment.h4j_1;
+        var limit = segment.i4j_1;
+        var data = segment.g4j_1;
         var tmp0 = pos;
         pos = tmp0 + 1 | 0;
         var b = data[tmp0];
-        this.k4i_1 = subtract(this.k4i_1, new (Long())(1, 0));
+        this.s4i_1 = subtract(this.s4i_1, new (Long())(1, 0));
         if (pos === limit) {
-          this.j4i_1 = segment.i4j();
-          SegmentPool_instance.p4j(segment);
+          this.r4i_1 = segment.q4j();
+          SegmentPool_instance.x4j(segment);
         } else {
-          segment.z4i_1 = pos;
+          segment.h4j_1 = pos;
         }
         return b;
       }
-      v4i() {
-        var tmp$ret$4;
+      d4j() {
+        var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonReadInt' call
-          if (compare(this.k4i_1, new (Long())(4, 0)) < 0)
-            throw EOFException().d4l();
-          var segment = ensureNotNull(this.j4i_1);
-          var pos = segment.z4i_1;
-          var limit = segment.a4j_1;
+          if (compare(this.s4i_1, new (Long())(4, 0)) < 0)
+            throw EOFException().l4l();
+          var segment = ensureNotNull(this.r4i_1);
+          var pos = segment.h4j_1;
+          var limit = segment.i4j_1;
           if (compare(fromInt(limit - pos | 0), new (Long())(4, 0)) < 0) {
             // Inline function 'okio.and' call
-            var tmp = (this.l1p() & 255) << 24;
+            var tmp = (this.g1p() & 255) << 24;
             // Inline function 'okio.and' call
-            var tmp_0 = tmp | (this.l1p() & 255) << 16;
+            var tmp_0 = tmp | (this.g1p() & 255) << 16;
             // Inline function 'okio.and' call
-            var tmp_1 = tmp_0 | (this.l1p() & 255) << 8;
+            var tmp_1 = tmp_0 | (this.g1p() & 255) << 8;
             // Inline function 'okio.and' call
-            tmp$ret$4 = tmp_1 | this.l1p() & 255;
+            tmp$ret$0 = tmp_1 | this.g1p() & 255;
             break $l$block;
           }
-          var data = segment.y4i_1;
+          var data = segment.g4j_1;
           var tmp3 = pos;
           pos = tmp3 + 1 | 0;
           // Inline function 'okio.and' call
@@ -262,106 +264,106 @@ function Buffer() {
           pos = tmp0 + 1 | 0;
           // Inline function 'okio.and' call
           var i = tmp_4 | data[tmp0] & 255;
-          this.k4i_1 = subtract(this.k4i_1, new (Long())(4, 0));
+          this.s4i_1 = subtract(this.s4i_1, new (Long())(4, 0));
           if (pos === limit) {
-            this.j4i_1 = segment.i4j();
-            SegmentPool_instance.p4j(segment);
+            this.r4i_1 = segment.q4j();
+            SegmentPool_instance.x4j(segment);
           } else {
-            segment.z4i_1 = pos;
+            segment.h4j_1 = pos;
           }
-          tmp$ret$4 = i;
+          tmp$ret$0 = i;
         }
-        return tmp$ret$4;
+        return tmp$ret$0;
       }
-      e4l() {
+      m4l() {
         // Inline function 'okio.internal.commonReadByteString' call
-        return this.f4l(this.k4i_1);
+        return this.n4l(this.s4i_1);
       }
-      f4l(byteCount) {
-        var tmp$ret$4;
+      n4l(byteCount) {
+        var tmp$ret$0;
         $l$block_0: {
           // Inline function 'okio.internal.commonReadByteString' call
           // Inline function 'kotlin.require' call
           if (!(compare(byteCount, new (Long())(0, 0)) >= 0 && compare(byteCount, new (Long())(2147483647, 0)) <= 0)) {
             var message = 'byteCount: ' + byteCount.toString();
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
-          if (compare(this.k4i_1, byteCount) < 0)
-            throw EOFException().d4l();
+          if (compare(this.s4i_1, byteCount) < 0)
+            throw EOFException().l4l();
           if (compare(byteCount, new (Long())(4096, 0)) >= 0) {
             // Inline function 'kotlin.also' call
-            var this_0 = this.h4l(convertToInt(byteCount));
-            this.f1q(byteCount);
-            tmp$ret$4 = this_0;
+            var this_0 = this.p4l(convertToInt(byteCount));
+            this.a1q(byteCount);
+            tmp$ret$0 = this_0;
             break $l$block_0;
           } else {
-            tmp$ret$4 = new (ByteString())(this.g4l(byteCount));
+            tmp$ret$0 = new (ByteString())(this.o4l(byteCount));
             break $l$block_0;
           }
         }
-        return tmp$ret$4;
+        return tmp$ret$0;
       }
-      i4l() {
-        return this.v4j(this.k4i_1);
+      q4l() {
+        return this.d4k(this.s4i_1);
       }
-      v4j(byteCount) {
-        var tmp$ret$2;
+      d4k(byteCount) {
+        var tmp$ret$0;
         $l$block_0: {
           // Inline function 'okio.internal.commonReadUtf8' call
           // Inline function 'kotlin.require' call
           if (!(compare(byteCount, new (Long())(0, 0)) >= 0 && compare(byteCount, new (Long())(2147483647, 0)) <= 0)) {
             var message = 'byteCount: ' + byteCount.toString();
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
-          if (compare(this.k4i_1, byteCount) < 0)
-            throw EOFException().d4l();
+          if (compare(this.s4i_1, byteCount) < 0)
+            throw EOFException().l4l();
           if (equalsLong(byteCount, new (Long())(0, 0))) {
-            tmp$ret$2 = '';
+            tmp$ret$0 = '';
             break $l$block_0;
           }
-          var s = ensureNotNull(this.j4i_1);
-          if (compare(add(numberToLong(s.z4i_1), byteCount), fromInt(s.a4j_1)) > 0) {
-            tmp$ret$2 = commonToUtf8String(this.g4l(byteCount));
+          var s = ensureNotNull(this.r4i_1);
+          if (compare(add(numberToLong(s.h4j_1), byteCount), fromInt(s.i4j_1)) > 0) {
+            tmp$ret$0 = commonToUtf8String(this.o4l(byteCount));
             break $l$block_0;
           }
-          var result = commonToUtf8String(s.y4i_1, s.z4i_1, s.z4i_1 + convertToInt(byteCount) | 0);
-          s.z4i_1 = s.z4i_1 + convertToInt(byteCount) | 0;
-          this.k4i_1 = subtract(this.k4i_1, byteCount);
-          if (s.z4i_1 === s.a4j_1) {
-            this.j4i_1 = s.i4j();
-            SegmentPool_instance.p4j(s);
+          var result = commonToUtf8String(s.g4j_1, s.h4j_1, s.h4j_1 + convertToInt(byteCount) | 0);
+          s.h4j_1 = s.h4j_1 + convertToInt(byteCount) | 0;
+          this.s4i_1 = subtract(this.s4i_1, byteCount);
+          if (s.h4j_1 === s.i4j_1) {
+            this.r4i_1 = s.q4j();
+            SegmentPool_instance.x4j(s);
           }
-          tmp$ret$2 = result;
+          tmp$ret$0 = result;
         }
-        return tmp$ret$2;
+        return tmp$ret$0;
       }
-      j4l() {
-        return this.k4l(new (Long())(-1, 2147483647));
+      r4l() {
+        return this.s4l(new (Long())(-1, 2147483647));
       }
-      k4l(limit) {
-        var tmp$ret$3;
+      s4l(limit) {
+        var tmp$ret$0;
         $l$block_0: {
           // Inline function 'okio.internal.commonReadUtf8LineStrict' call
           // Inline function 'kotlin.require' call
           if (!(compare(limit, new (Long())(0, 0)) >= 0)) {
             var message = 'limit < 0: ' + limit.toString();
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
           var scanLength = equalsLong(limit, new (Long())(-1, 2147483647)) ? new (Long())(-1, 2147483647) : add(limit, new (Long())(1, 0));
           // Inline function 'kotlin.code' call
           var this_0 = _Char___init__impl__6a9atx(10);
-          var tmp$ret$2 = Char__toInt_impl_vasixd(this_0);
-          var newline = this.l4l(toByte(tmp$ret$2), new (Long())(0, 0), scanLength);
+          var tmp$ret$3 = Char__toInt_impl_vasixd(this_0);
+          var newline = this.t4l(toByte(tmp$ret$3), new (Long())(0, 0), scanLength);
           if (!equalsLong(newline, new (Long())(-1, -1))) {
-            tmp$ret$3 = readUtf8Line(this, newline);
+            tmp$ret$0 = readUtf8Line(this, newline);
             break $l$block_0;
           }
           var tmp;
           var tmp_0;
-          if (compare(scanLength, this.k4i_1) < 0) {
+          if (compare(scanLength, this.s4i_1) < 0) {
             // Inline function 'kotlin.Long.minus' call
             var tmp$ret$4 = subtract(scanLength, fromInt(1));
-            var tmp_1 = this.d1q(tmp$ret$4);
+            var tmp_1 = this.y1p(tmp$ret$4);
             // Inline function 'kotlin.code' call
             var this_1 = _Char___init__impl__6a9atx(13);
             var tmp$ret$5 = Char__toInt_impl_vasixd(this_1);
@@ -370,7 +372,7 @@ function Buffer() {
             tmp_0 = false;
           }
           if (tmp_0) {
-            var tmp_2 = this.d1q(scanLength);
+            var tmp_2 = this.y1p(scanLength);
             // Inline function 'kotlin.code' call
             var this_2 = _Char___init__impl__6a9atx(10);
             var tmp$ret$6 = Char__toInt_impl_vasixd(this_2);
@@ -379,25 +381,25 @@ function Buffer() {
             tmp = false;
           }
           if (tmp) {
-            tmp$ret$3 = readUtf8Line(this, scanLength);
+            tmp$ret$0 = readUtf8Line(this, scanLength);
             break $l$block_0;
           }
           var data = new (Buffer())();
           var tmp_3 = new (Long())(0, 0);
           // Inline function 'okio.minOf' call
-          var b = this.k4i_1;
+          var b = this.s4i_1;
           // Inline function 'kotlin.comparisons.minOf' call
           var a = fromInt(32);
-          var tmp$ret$8 = compare(a, b) <= 0 ? a : b;
-          this.b4l(data, tmp_3, tmp$ret$8);
+          var tmp$ret$7 = compare(a, b) <= 0 ? a : b;
+          this.j4l(data, tmp_3, tmp$ret$7);
           // Inline function 'kotlin.comparisons.minOf' call
-          var a_0 = this.k4i_1;
+          var a_0 = this.s4i_1;
           var tmp$ret$9 = compare(a_0, limit) <= 0 ? a_0 : limit;
-          throw EOFException().a4l('\\n not found: limit=' + tmp$ret$9.toString() + ' content=' + data.e4l().i4k() + '\u2026');
+          throw EOFException().i4l('\\n not found: limit=' + tmp$ret$9.toString() + ' content=' + data.m4l().q4k() + '\u2026');
         }
-        return tmp$ret$3;
+        return tmp$ret$0;
       }
-      m4l(options) {
+      u4l(options) {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonSelect' call
@@ -406,46 +408,46 @@ function Buffer() {
             tmp$ret$0 = -1;
             break $l$block;
           }
-          var selectedSize = options.r4i_1[index].v2();
-          this.f1q(fromInt(selectedSize));
+          var selectedSize = options.z4i_1[index].q2();
+          this.a1q(fromInt(selectedSize));
           tmp$ret$0 = index;
         }
         return tmp$ret$0;
       }
-      n4l() {
+      v4l() {
         // Inline function 'okio.internal.commonReadByteArray' call
-        return this.g4l(this.k4i_1);
+        return this.o4l(this.s4i_1);
       }
-      g4l(byteCount) {
+      o4l(byteCount) {
         // Inline function 'okio.internal.commonReadByteArray' call
         // Inline function 'kotlin.require' call
         if (!(compare(byteCount, new (Long())(0, 0)) >= 0 && compare(byteCount, new (Long())(2147483647, 0)) <= 0)) {
           var message = 'byteCount: ' + byteCount.toString();
-          throw IllegalArgumentException().r2(toString(message));
+          throw IllegalArgumentException().m2(toString(message));
         }
-        if (compare(this.k4i_1, byteCount) < 0)
-          throw EOFException().d4l();
+        if (compare(this.s4i_1, byteCount) < 0)
+          throw EOFException().l4l();
         var result = new Int8Array(convertToInt(byteCount));
-        this.o4l(result);
+        this.w4l(result);
         return result;
       }
-      o4l(sink) {
+      w4l(sink) {
         // Inline function 'okio.internal.commonReadFully' call
         var offset = 0;
         while (offset < sink.length) {
-          var read = this.p4l(sink, offset, sink.length - offset | 0);
+          var read = this.x4l(sink, offset, sink.length - offset | 0);
           if (read === -1)
-            throw EOFException().d4l();
+            throw EOFException().l4l();
           offset = offset + read | 0;
         }
         return Unit_instance;
       }
-      p4l(sink, offset, byteCount) {
+      x4l(sink, offset, byteCount) {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonRead' call
           checkOffsetAndCount(fromInt(sink.length), fromInt(offset), fromInt(byteCount));
-          var tmp0_elvis_lhs = this.j4i_1;
+          var tmp0_elvis_lhs = this.r4i_1;
           var tmp;
           if (tmp0_elvis_lhs == null) {
             tmp$ret$0 = -1;
@@ -455,112 +457,112 @@ function Buffer() {
           }
           var s = tmp;
           // Inline function 'kotlin.comparisons.minOf' call
-          var b = s.a4j_1 - s.z4i_1 | 0;
+          var b = s.i4j_1 - s.h4j_1 | 0;
           var toCopy = Math.min(byteCount, b);
-          var tmp0 = s.y4i_1;
-          var tmp6 = s.z4i_1;
+          var tmp0 = s.g4j_1;
+          var tmp6 = s.h4j_1;
           // Inline function 'kotlin.collections.copyInto' call
-          var endIndex = s.z4i_1 + toCopy | 0;
+          var endIndex = s.h4j_1 + toCopy | 0;
           // Inline function 'kotlin.js.unsafeCast' call
           // Inline function 'kotlin.js.asDynamic' call
           var tmp_0 = tmp0;
           // Inline function 'kotlin.js.unsafeCast' call
           // Inline function 'kotlin.js.asDynamic' call
           arrayCopy(tmp_0, sink, offset, tmp6, endIndex);
-          s.z4i_1 = s.z4i_1 + toCopy | 0;
-          this.k4i_1 = subtract(this.k4i_1, fromInt(toCopy));
-          if (s.z4i_1 === s.a4j_1) {
-            this.j4i_1 = s.i4j();
-            SegmentPool_instance.p4j(s);
+          s.h4j_1 = s.h4j_1 + toCopy | 0;
+          this.s4i_1 = subtract(this.s4i_1, fromInt(toCopy));
+          if (s.h4j_1 === s.i4j_1) {
+            this.r4i_1 = s.q4j();
+            SegmentPool_instance.x4j(s);
           }
           tmp$ret$0 = toCopy;
         }
         return tmp$ret$0;
       }
-      r4() {
+      m4() {
         // Inline function 'okio.internal.commonClear' call
-        this.f1q(this.k4i_1);
+        this.a1q(this.s4i_1);
         return Unit_instance;
       }
-      f1q(byteCount) {
+      a1q(byteCount) {
         // Inline function 'okio.internal.commonSkip' call
         var byteCount_0 = byteCount;
         while (compare(byteCount_0, new (Long())(0, 0)) > 0) {
-          var tmp0_elvis_lhs = this.j4i_1;
+          var tmp0_elvis_lhs = this.r4i_1;
           var tmp;
           if (tmp0_elvis_lhs == null) {
-            throw EOFException().d4l();
+            throw EOFException().l4l();
           } else {
             tmp = tmp0_elvis_lhs;
           }
           var head = tmp;
           var tmp0 = byteCount_0;
           // Inline function 'okio.minOf' call
-          var b = head.a4j_1 - head.z4i_1 | 0;
+          var b = head.i4j_1 - head.h4j_1 | 0;
           // Inline function 'kotlin.comparisons.minOf' call
           var b_0 = fromInt(b);
           var tmp$ret$1 = compare(tmp0, b_0) <= 0 ? tmp0 : b_0;
           var toSkip = convertToInt(tmp$ret$1);
-          this.k4i_1 = subtract(this.k4i_1, fromInt(toSkip));
+          this.s4i_1 = subtract(this.s4i_1, fromInt(toSkip));
           byteCount_0 = subtract(byteCount_0, fromInt(toSkip));
-          head.z4i_1 = head.z4i_1 + toSkip | 0;
-          if (head.z4i_1 === head.a4j_1) {
-            this.j4i_1 = head.i4j();
-            SegmentPool_instance.p4j(head);
+          head.h4j_1 = head.h4j_1 + toSkip | 0;
+          if (head.h4j_1 === head.i4j_1) {
+            this.r4i_1 = head.q4j();
+            SegmentPool_instance.x4j(head);
           }
         }
         return Unit_instance;
       }
-      q4l(byteString) {
+      y4l(byteString) {
         // Inline function 'okio.internal.commonWrite' call
-        var byteCount = byteString.v2();
-        byteString.m4k(this, 0, byteCount);
+        var byteCount = byteString.q2();
+        byteString.u4k(this, 0, byteCount);
         return this;
       }
-      r4l(minimumCapacity) {
-        var tmp$ret$2;
+      z4l(minimumCapacity) {
+        var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonWritableSegment' call
           // Inline function 'kotlin.require' call
           if (!(minimumCapacity >= 1 && minimumCapacity <= 8192)) {
             var message = 'unexpected capacity';
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
-          if (this.j4i_1 == null) {
-            var result = SegmentPool_instance.q1q();
-            this.j4i_1 = result;
-            result.e4j_1 = result;
-            result.d4j_1 = result;
-            tmp$ret$2 = result;
+          if (this.r4i_1 == null) {
+            var result = SegmentPool_instance.l1q();
+            this.r4i_1 = result;
+            result.m4j_1 = result;
+            result.l4j_1 = result;
+            tmp$ret$0 = result;
             break $l$block;
           }
-          var tail = ensureNotNull(this.j4i_1).e4j_1;
-          if ((ensureNotNull(tail).a4j_1 + minimumCapacity | 0) > 8192 || !tail.c4j_1) {
-            tail = tail.j4j(SegmentPool_instance.q1q());
+          var tail = ensureNotNull(this.r4i_1).m4j_1;
+          if ((ensureNotNull(tail).i4j_1 + minimumCapacity | 0) > 8192 || !tail.k4j_1) {
+            tail = tail.r4j(SegmentPool_instance.l1q());
           }
-          tmp$ret$2 = tail;
+          tmp$ret$0 = tail;
         }
-        return tmp$ret$2;
+        return tmp$ret$0;
       }
-      s4l(string) {
-        return this.t4l(string, 0, string.length);
+      a4m(string) {
+        return this.b4m(string, 0, string.length);
       }
-      t4l(string, beginIndex, endIndex) {
+      b4m(string, beginIndex, endIndex) {
         // Inline function 'okio.internal.commonWriteUtf8' call
         // Inline function 'kotlin.require' call
         if (!(beginIndex >= 0)) {
           var message = 'beginIndex < 0: ' + beginIndex;
-          throw IllegalArgumentException().r2(toString(message));
+          throw IllegalArgumentException().m2(toString(message));
         }
         // Inline function 'kotlin.require' call
         if (!(endIndex >= beginIndex)) {
           var message_0 = 'endIndex < beginIndex: ' + endIndex + ' < ' + beginIndex;
-          throw IllegalArgumentException().r2(toString(message_0));
+          throw IllegalArgumentException().m2(toString(message_0));
         }
         // Inline function 'kotlin.require' call
         if (!(endIndex <= string.length)) {
           var message_1 = 'endIndex > string.length: ' + endIndex + ' > ' + string.length;
-          throw IllegalArgumentException().r2(toString(message_1));
+          throw IllegalArgumentException().m2(toString(message_1));
         }
         var i = beginIndex;
         while (i < endIndex) {
@@ -568,9 +570,9 @@ function Buffer() {
           var this_0 = charCodeAt(string, i);
           var c = Char__toInt_impl_vasixd(this_0);
           if (c < 128) {
-            var tail = this.r4l(1);
-            var data = tail.y4i_1;
-            var segmentOffset = tail.a4j_1 - i | 0;
+            var tail = this.z4l(1);
+            var data = tail.g4j_1;
+            var segmentOffset = tail.i4j_1 - i | 0;
             // Inline function 'kotlin.comparisons.minOf' call
             var b = 8192 - segmentOffset | 0;
             var runLimit = Math.min(endIndex, b);
@@ -587,23 +589,23 @@ function Buffer() {
               i = tmp1 + 1 | 0;
               data[segmentOffset + tmp1 | 0] = toByte(c);
             }
-            var runSize = (i + segmentOffset | 0) - tail.a4j_1 | 0;
-            tail.a4j_1 = tail.a4j_1 + runSize | 0;
-            this.k4i_1 = add(this.k4i_1, fromInt(runSize));
+            var runSize = (i + segmentOffset | 0) - tail.i4j_1 | 0;
+            tail.i4j_1 = tail.i4j_1 + runSize | 0;
+            this.s4i_1 = add(this.s4i_1, fromInt(runSize));
           } else if (c < 2048) {
-            var tail_0 = this.r4l(2);
-            tail_0.y4i_1[tail_0.a4j_1] = toByte(c >> 6 | 192);
-            tail_0.y4i_1[tail_0.a4j_1 + 1 | 0] = toByte(c & 63 | 128);
-            tail_0.a4j_1 = tail_0.a4j_1 + 2 | 0;
-            this.k4i_1 = add(this.k4i_1, new (Long())(2, 0));
+            var tail_0 = this.z4l(2);
+            tail_0.g4j_1[tail_0.i4j_1] = toByte(c >> 6 | 192);
+            tail_0.g4j_1[tail_0.i4j_1 + 1 | 0] = toByte(c & 63 | 128);
+            tail_0.i4j_1 = tail_0.i4j_1 + 2 | 0;
+            this.s4i_1 = add(this.s4i_1, new (Long())(2, 0));
             i = i + 1 | 0;
           } else if (c < 55296 || c > 57343) {
-            var tail_1 = this.r4l(3);
-            tail_1.y4i_1[tail_1.a4j_1] = toByte(c >> 12 | 224);
-            tail_1.y4i_1[tail_1.a4j_1 + 1 | 0] = toByte(c >> 6 & 63 | 128);
-            tail_1.y4i_1[tail_1.a4j_1 + 2 | 0] = toByte(c & 63 | 128);
-            tail_1.a4j_1 = tail_1.a4j_1 + 3 | 0;
-            this.k4i_1 = add(this.k4i_1, new (Long())(3, 0));
+            var tail_1 = this.z4l(3);
+            tail_1.g4j_1[tail_1.i4j_1] = toByte(c >> 12 | 224);
+            tail_1.g4j_1[tail_1.i4j_1 + 1 | 0] = toByte(c >> 6 & 63 | 128);
+            tail_1.g4j_1[tail_1.i4j_1 + 2 | 0] = toByte(c & 63 | 128);
+            tail_1.i4j_1 = tail_1.i4j_1 + 3 | 0;
+            this.s4i_1 = add(this.s4i_1, new (Long())(3, 0));
             i = i + 1 | 0;
           } else {
             var tmp;
@@ -618,41 +620,41 @@ function Buffer() {
             if (c > 56319 || !(56320 <= low ? low <= 57343 : false)) {
               // Inline function 'kotlin.code' call
               var this_3 = _Char___init__impl__6a9atx(63);
-              var tmp$ret$10 = Char__toInt_impl_vasixd(this_3);
-              this.u4l(tmp$ret$10);
+              var tmp$ret$11 = Char__toInt_impl_vasixd(this_3);
+              this.c4m(tmp$ret$11);
               i = i + 1 | 0;
             } else {
               var codePoint = 65536 + ((c & 1023) << 10 | low & 1023) | 0;
-              var tail_2 = this.r4l(4);
-              tail_2.y4i_1[tail_2.a4j_1] = toByte(codePoint >> 18 | 240);
-              tail_2.y4i_1[tail_2.a4j_1 + 1 | 0] = toByte(codePoint >> 12 & 63 | 128);
-              tail_2.y4i_1[tail_2.a4j_1 + 2 | 0] = toByte(codePoint >> 6 & 63 | 128);
-              tail_2.y4i_1[tail_2.a4j_1 + 3 | 0] = toByte(codePoint & 63 | 128);
-              tail_2.a4j_1 = tail_2.a4j_1 + 4 | 0;
-              this.k4i_1 = add(this.k4i_1, new (Long())(4, 0));
+              var tail_2 = this.z4l(4);
+              tail_2.g4j_1[tail_2.i4j_1] = toByte(codePoint >> 18 | 240);
+              tail_2.g4j_1[tail_2.i4j_1 + 1 | 0] = toByte(codePoint >> 12 & 63 | 128);
+              tail_2.g4j_1[tail_2.i4j_1 + 2 | 0] = toByte(codePoint >> 6 & 63 | 128);
+              tail_2.g4j_1[tail_2.i4j_1 + 3 | 0] = toByte(codePoint & 63 | 128);
+              tail_2.i4j_1 = tail_2.i4j_1 + 4 | 0;
+              this.s4i_1 = add(this.s4i_1, new (Long())(4, 0));
               i = i + 2 | 0;
             }
           }
         }
         return this;
       }
-      v4l(source) {
+      d4m(source) {
         // Inline function 'okio.internal.commonWrite' call
-        return this.w4j(source, 0, source.length);
+        return this.e4k(source, 0, source.length);
       }
-      w4j(source, offset, byteCount) {
+      e4k(source, offset, byteCount) {
         // Inline function 'okio.internal.commonWrite' call
         var offset_0 = offset;
         checkOffsetAndCount(fromInt(source.length), fromInt(offset_0), fromInt(byteCount));
         var limit = offset_0 + byteCount | 0;
         while (offset_0 < limit) {
-          var tail = this.r4l(1);
+          var tail = this.z4l(1);
           var tmp0 = limit - offset_0 | 0;
           // Inline function 'kotlin.comparisons.minOf' call
-          var b = 8192 - tail.a4j_1 | 0;
+          var b = 8192 - tail.i4j_1 | 0;
           var toCopy = Math.min(tmp0, b);
-          var tmp2 = tail.y4i_1;
-          var tmp4 = tail.a4j_1;
+          var tmp2 = tail.g4j_1;
+          var tmp4 = tail.i4j_1;
           var tmp6 = offset_0;
           // Inline function 'kotlin.collections.copyInto' call
           var endIndex = offset_0 + toCopy | 0;
@@ -663,36 +665,36 @@ function Buffer() {
           // Inline function 'kotlin.js.asDynamic' call
           arrayCopy(tmp, tmp2, tmp4, tmp6, endIndex);
           offset_0 = offset_0 + toCopy | 0;
-          tail.a4j_1 = tail.a4j_1 + toCopy | 0;
+          tail.i4j_1 = tail.i4j_1 + toCopy | 0;
         }
-        this.k4i_1 = add(this.k4i_1, fromInt(byteCount));
+        this.s4i_1 = add(this.s4i_1, fromInt(byteCount));
         return this;
       }
-      p4i(source) {
+      x4i(source) {
         // Inline function 'okio.internal.commonWriteAll' call
         var totalBytesRead = new (Long())(0, 0);
         $l$loop: while (true) {
-          var readCount = source.w4l(this, new (Long())(8192, 0));
+          var readCount = source.e4m(this, new (Long())(8192, 0));
           if (equalsLong(readCount, new (Long())(-1, -1)))
             break $l$loop;
           totalBytesRead = add(totalBytesRead, readCount);
         }
         return totalBytesRead;
       }
-      u4l(b) {
+      c4m(b) {
         // Inline function 'okio.internal.commonWriteByte' call
-        var tail = this.r4l(1);
-        var tmp1 = tail.a4j_1;
-        tail.a4j_1 = tmp1 + 1 | 0;
-        tail.y4i_1[tmp1] = toByte(b);
-        this.k4i_1 = add(this.k4i_1, new (Long())(1, 0));
+        var tail = this.z4l(1);
+        var tmp1 = tail.i4j_1;
+        tail.i4j_1 = tmp1 + 1 | 0;
+        tail.g4j_1[tmp1] = toByte(b);
+        this.s4i_1 = add(this.s4i_1, new (Long())(1, 0));
         return this;
       }
-      o4i(i) {
+      w4i(i) {
         // Inline function 'okio.internal.commonWriteInt' call
-        var tail = this.r4l(4);
-        var data = tail.y4i_1;
-        var limit = tail.a4j_1;
+        var tail = this.z4l(4);
+        var data = tail.g4j_1;
+        var limit = tail.i4j_1;
         var tmp0 = limit;
         limit = tmp0 + 1 | 0;
         data[tmp0] = toByte((i >>> 24 | 0) & 255);
@@ -705,633 +707,639 @@ function Buffer() {
         var tmp3 = limit;
         limit = tmp3 + 1 | 0;
         data[tmp3] = toByte(i & 255);
-        tail.a4j_1 = limit;
-        this.k4i_1 = add(this.k4i_1, new (Long())(4, 0));
+        tail.i4j_1 = limit;
+        this.s4i_1 = add(this.s4i_1, new (Long())(4, 0));
         return this;
       }
-      i4i(source, byteCount) {
-        var tmp$ret$4;
+      q4i(source, byteCount) {
+        var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonWrite' call
           var byteCount_0 = byteCount;
           // Inline function 'kotlin.require' call
           if (!!(source === this)) {
             var message = 'source == this';
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
-          checkOffsetAndCount(source.k4i_1, new (Long())(0, 0), byteCount_0);
+          checkOffsetAndCount(source.s4i_1, new (Long())(0, 0), byteCount_0);
           while (compare(byteCount_0, new (Long())(0, 0)) > 0) {
-            if (compare(byteCount_0, fromInt(ensureNotNull(source.j4i_1).a4j_1 - ensureNotNull(source.j4i_1).z4i_1 | 0)) < 0) {
-              var tail = !(this.j4i_1 == null) ? ensureNotNull(this.j4i_1).e4j_1 : null;
+            if (compare(byteCount_0, fromInt(ensureNotNull(source.r4i_1).i4j_1 - ensureNotNull(source.r4i_1).h4j_1 | 0)) < 0) {
+              var tail = !(this.r4i_1 == null) ? ensureNotNull(this.r4i_1).m4j_1 : null;
               var tmp;
-              if (!(tail == null) && tail.c4j_1) {
+              if (!(tail == null) && tail.k4j_1) {
                 var tmp0 = byteCount_0;
                 // Inline function 'kotlin.Long.plus' call
-                var other = tail.a4j_1;
+                var other = tail.i4j_1;
                 var tmp0_0 = add(tmp0, fromInt(other));
                 // Inline function 'kotlin.Long.minus' call
-                var other_0 = tail.b4j_1 ? 0 : tail.z4i_1;
-                var tmp$ret$3 = subtract(tmp0_0, fromInt(other_0));
-                tmp = compare(tmp$ret$3, new (Long())(8192, 0)) <= 0;
+                var other_0 = tail.j4j_1 ? 0 : tail.h4j_1;
+                var tmp$ret$4 = subtract(tmp0_0, fromInt(other_0));
+                tmp = compare(tmp$ret$4, new (Long())(8192, 0)) <= 0;
               } else {
                 tmp = false;
               }
               if (tmp) {
-                ensureNotNull(source.j4i_1).o4j(tail, convertToInt(byteCount_0));
-                source.k4i_1 = subtract(source.k4i_1, byteCount_0);
-                this.k4i_1 = add(this.k4i_1, byteCount_0);
-                tmp$ret$4 = Unit_instance;
+                ensureNotNull(source.r4i_1).w4j(tail, convertToInt(byteCount_0));
+                source.s4i_1 = subtract(source.s4i_1, byteCount_0);
+                this.s4i_1 = add(this.s4i_1, byteCount_0);
+                tmp$ret$0 = Unit_instance;
                 break $l$block;
               } else {
-                source.j4i_1 = ensureNotNull(source.j4i_1).k4j(convertToInt(byteCount_0));
+                source.r4i_1 = ensureNotNull(source.r4i_1).s4j(convertToInt(byteCount_0));
               }
             }
-            var segmentToMove = source.j4i_1;
-            var movedByteCount = fromInt(ensureNotNull(segmentToMove).a4j_1 - segmentToMove.z4i_1 | 0);
-            source.j4i_1 = segmentToMove.i4j();
-            if (this.j4i_1 == null) {
-              this.j4i_1 = segmentToMove;
-              segmentToMove.e4j_1 = segmentToMove;
-              segmentToMove.d4j_1 = segmentToMove.e4j_1;
+            var segmentToMove = source.r4i_1;
+            var movedByteCount = fromInt(ensureNotNull(segmentToMove).i4j_1 - segmentToMove.h4j_1 | 0);
+            source.r4i_1 = segmentToMove.q4j();
+            if (this.r4i_1 == null) {
+              this.r4i_1 = segmentToMove;
+              segmentToMove.m4j_1 = segmentToMove;
+              segmentToMove.l4j_1 = segmentToMove.m4j_1;
             } else {
-              var tail_0 = ensureNotNull(this.j4i_1).e4j_1;
-              tail_0 = ensureNotNull(tail_0).j4j(segmentToMove);
-              tail_0.n4j();
+              var tail_0 = ensureNotNull(this.r4i_1).m4j_1;
+              tail_0 = ensureNotNull(tail_0).r4j(segmentToMove);
+              tail_0.v4j();
             }
-            source.k4i_1 = subtract(source.k4i_1, movedByteCount);
-            this.k4i_1 = add(this.k4i_1, movedByteCount);
+            source.s4i_1 = subtract(source.s4i_1, movedByteCount);
+            this.s4i_1 = add(this.s4i_1, movedByteCount);
             byteCount_0 = subtract(byteCount_0, movedByteCount);
           }
-          tmp$ret$4 = Unit_instance;
+          tmp$ret$0 = Unit_instance;
         }
-        return tmp$ret$4;
+        return tmp$ret$0;
       }
-      w4l(sink, byteCount) {
-        var tmp$ret$2;
+      e4m(sink, byteCount) {
+        var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonRead' call
           var byteCount_0 = byteCount;
           // Inline function 'kotlin.require' call
           if (!(compare(byteCount_0, new (Long())(0, 0)) >= 0)) {
             var message = 'byteCount < 0: ' + byteCount_0.toString();
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
-          if (equalsLong(this.k4i_1, new (Long())(0, 0))) {
-            tmp$ret$2 = new (Long())(-1, -1);
+          if (equalsLong(this.s4i_1, new (Long())(0, 0))) {
+            tmp$ret$0 = new (Long())(-1, -1);
             break $l$block;
           }
-          if (compare(byteCount_0, this.k4i_1) > 0)
-            byteCount_0 = this.k4i_1;
-          sink.i4i(this, byteCount_0);
-          tmp$ret$2 = byteCount_0;
+          if (compare(byteCount_0, this.s4i_1) > 0)
+            byteCount_0 = this.s4i_1;
+          sink.q4i(this, byteCount_0);
+          tmp$ret$0 = byteCount_0;
         }
-        return tmp$ret$2;
+        return tmp$ret$0;
       }
-      l4l(b, fromIndex, toIndex) {
-        var tmp$ret$2;
-        $l$block_8: {
+      t4l(b, fromIndex, toIndex) {
+        var tmp$ret$0;
+        $l$block_10: {
           // Inline function 'okio.internal.commonIndexOf' call
           var fromIndex_0 = fromIndex;
           var toIndex_0 = toIndex;
           // Inline function 'kotlin.require' call
           if (!(compare(new (Long())(0, 0), fromIndex_0) <= 0 ? compare(fromIndex_0, toIndex_0) <= 0 : false)) {
-            var message = 'size=' + this.k4i_1.toString() + ' fromIndex=' + fromIndex_0.toString() + ' toIndex=' + toIndex_0.toString();
-            throw IllegalArgumentException().r2(toString(message));
+            var message = 'size=' + this.s4i_1.toString() + ' fromIndex=' + fromIndex_0.toString() + ' toIndex=' + toIndex_0.toString();
+            throw IllegalArgumentException().m2(toString(message));
           }
-          if (compare(toIndex_0, this.k4i_1) > 0)
-            toIndex_0 = this.k4i_1;
+          if (compare(toIndex_0, this.s4i_1) > 0)
+            toIndex_0 = this.s4i_1;
           if (equalsLong(fromIndex_0, toIndex_0)) {
-            tmp$ret$2 = new (Long())(-1, -1);
-            break $l$block_8;
+            tmp$ret$0 = new (Long())(-1, -1);
+            break $l$block_10;
           }
-          // Inline function 'okio.internal.seek' call
-          var fromIndex_1 = fromIndex_0;
-          var tmp0_elvis_lhs = this.j4i_1;
-          var tmp;
-          if (tmp0_elvis_lhs == null) {
-            var offset = new (Long())(-1, -1);
-            var tmp_0;
-            if (null == null) {
-              tmp$ret$2 = new (Long())(-1, -1);
-              break $l$block_8;
-            } else {
-              tmp_0 = null;
-            }
-            var s = tmp_0;
-            var offset_0 = offset;
-            while (compare(offset_0, toIndex_0) < 0) {
-              var data = s.y4i_1;
-              var tmp0 = fromInt(s.a4j_1);
-              // Inline function 'kotlin.comparisons.minOf' call
-              var b_0 = subtract(add(numberToLong(s.z4i_1), toIndex_0), offset_0);
-              var tmp$ret$3 = compare(tmp0, b_0) <= 0 ? tmp0 : b_0;
-              var limit = convertToInt(tmp$ret$3);
-              var pos = convertToInt(subtract(add(numberToLong(s.z4i_1), fromIndex_0), offset_0));
-              while (pos < limit) {
-                if (data[pos] === b) {
-                  tmp$ret$2 = add(numberToLong(pos - s.z4i_1 | 0), offset_0);
-                  break $l$block_8;
+          var tmp2 = fromIndex_0;
+          $l$block_11: {
+            // Inline function 'okio.internal.seek' call
+            var tmp0_elvis_lhs = this.r4i_1;
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var offset = new (Long())(-1, -1);
+              var tmp_0;
+              if (null == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_10;
+              } else {
+                tmp_0 = null;
+              }
+              var s = tmp_0;
+              var offset_0 = offset;
+              while (compare(offset_0, toIndex_0) < 0) {
+                var data = s.g4j_1;
+                var tmp0 = fromInt(s.i4j_1);
+                // Inline function 'kotlin.comparisons.minOf' call
+                var b_0 = subtract(add(numberToLong(s.h4j_1), toIndex_0), offset_0);
+                var tmp$ret$5 = compare(tmp0, b_0) <= 0 ? tmp0 : b_0;
+                var limit = convertToInt(tmp$ret$5);
+                var pos = convertToInt(subtract(add(numberToLong(s.h4j_1), fromIndex_0), offset_0));
+                while (pos < limit) {
+                  if (data[pos] === b) {
+                    tmp$ret$0 = add(numberToLong(pos - s.h4j_1 | 0), offset_0);
+                    break $l$block_10;
+                  }
+                  pos = pos + 1 | 0;
                 }
-                pos = pos + 1 | 0;
+                offset_0 = add(offset_0, fromInt(s.i4j_1 - s.h4j_1 | 0));
+                fromIndex_0 = offset_0;
+                s = ensureNotNull(s.l4j_1);
               }
-              offset_0 = add(offset_0, fromInt(s.a4j_1 - s.z4i_1 | 0));
-              fromIndex_0 = offset_0;
-              s = ensureNotNull(s.d4j_1);
-            }
-            tmp$ret$2 = new (Long())(-1, -1);
-            break $l$block_8;
-          } else {
-            tmp = tmp0_elvis_lhs;
-          }
-          var s_0 = tmp;
-          if (compare(subtract(this.k4i_1, fromIndex_1), fromIndex_1) < 0) {
-            var offset_1 = this.k4i_1;
-            while (compare(offset_1, fromIndex_1) > 0) {
-              s_0 = ensureNotNull(s_0.e4j_1);
-              offset_1 = subtract(offset_1, fromInt(s_0.a4j_1 - s_0.z4i_1 | 0));
-            }
-            var tmp0_0 = s_0;
-            var offset_2 = offset_1;
-            var tmp_1;
-            if (tmp0_0 == null) {
-              tmp$ret$2 = new (Long())(-1, -1);
-              break $l$block_8;
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_10;
             } else {
-              tmp_1 = tmp0_0;
+              tmp = tmp0_elvis_lhs;
             }
-            var s_1 = tmp_1;
-            var offset_3 = offset_2;
-            while (compare(offset_3, toIndex_0) < 0) {
-              var data_0 = s_1.y4i_1;
-              var tmp0_1 = fromInt(s_1.a4j_1);
-              // Inline function 'kotlin.comparisons.minOf' call
-              var b_1 = subtract(add(numberToLong(s_1.z4i_1), toIndex_0), offset_3);
-              var tmp$ret$5 = compare(tmp0_1, b_1) <= 0 ? tmp0_1 : b_1;
-              var limit_0 = convertToInt(tmp$ret$5);
-              var pos_0 = convertToInt(subtract(add(numberToLong(s_1.z4i_1), fromIndex_0), offset_3));
-              while (pos_0 < limit_0) {
-                if (data_0[pos_0] === b) {
-                  tmp$ret$2 = add(numberToLong(pos_0 - s_1.z4i_1 | 0), offset_3);
-                  break $l$block_8;
+            var s_0 = tmp;
+            if (compare(subtract(this.s4i_1, tmp2), tmp2) < 0) {
+              var offset_1 = this.s4i_1;
+              while (compare(offset_1, tmp2) > 0) {
+                s_0 = ensureNotNull(s_0.m4j_1);
+                offset_1 = subtract(offset_1, fromInt(s_0.i4j_1 - s_0.h4j_1 | 0));
+              }
+              var tmp0_0 = s_0;
+              var offset_2 = offset_1;
+              var tmp_1;
+              if (tmp0_0 == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_10;
+              } else {
+                tmp_1 = tmp0_0;
+              }
+              var s_1 = tmp_1;
+              var offset_3 = offset_2;
+              while (compare(offset_3, toIndex_0) < 0) {
+                var data_0 = s_1.g4j_1;
+                var tmp0_1 = fromInt(s_1.i4j_1);
+                // Inline function 'kotlin.comparisons.minOf' call
+                var b_1 = subtract(add(numberToLong(s_1.h4j_1), toIndex_0), offset_3);
+                var tmp$ret$7 = compare(tmp0_1, b_1) <= 0 ? tmp0_1 : b_1;
+                var limit_0 = convertToInt(tmp$ret$7);
+                var pos_0 = convertToInt(subtract(add(numberToLong(s_1.h4j_1), fromIndex_0), offset_3));
+                while (pos_0 < limit_0) {
+                  if (data_0[pos_0] === b) {
+                    tmp$ret$0 = add(numberToLong(pos_0 - s_1.h4j_1 | 0), offset_3);
+                    break $l$block_10;
+                  }
+                  pos_0 = pos_0 + 1 | 0;
                 }
-                pos_0 = pos_0 + 1 | 0;
+                offset_3 = add(offset_3, fromInt(s_1.i4j_1 - s_1.h4j_1 | 0));
+                fromIndex_0 = offset_3;
+                s_1 = ensureNotNull(s_1.l4j_1);
               }
-              offset_3 = add(offset_3, fromInt(s_1.a4j_1 - s_1.z4i_1 | 0));
-              fromIndex_0 = offset_3;
-              s_1 = ensureNotNull(s_1.d4j_1);
-            }
-            tmp$ret$2 = new (Long())(-1, -1);
-            break $l$block_8;
-          } else {
-            var offset_4 = new (Long())(0, 0);
-            $l$loop: while (true) {
-              var tmp0_2 = offset_4;
-              // Inline function 'kotlin.Long.plus' call
-              var other = s_0.a4j_1 - s_0.z4i_1 | 0;
-              var nextOffset = add(tmp0_2, fromInt(other));
-              if (compare(nextOffset, fromIndex_1) > 0)
-                break $l$loop;
-              s_0 = ensureNotNull(s_0.d4j_1);
-              offset_4 = nextOffset;
-            }
-            var tmp0_3 = s_0;
-            var offset_5 = offset_4;
-            var tmp_2;
-            if (tmp0_3 == null) {
-              tmp$ret$2 = new (Long())(-1, -1);
-              break $l$block_8;
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_10;
             } else {
-              tmp_2 = tmp0_3;
-            }
-            var s_2 = tmp_2;
-            var offset_6 = offset_5;
-            while (compare(offset_6, toIndex_0) < 0) {
-              var data_1 = s_2.y4i_1;
-              var tmp0_4 = fromInt(s_2.a4j_1);
-              // Inline function 'kotlin.comparisons.minOf' call
-              var b_2 = subtract(add(numberToLong(s_2.z4i_1), toIndex_0), offset_6);
-              var tmp$ret$7 = compare(tmp0_4, b_2) <= 0 ? tmp0_4 : b_2;
-              var limit_1 = convertToInt(tmp$ret$7);
-              var pos_1 = convertToInt(subtract(add(numberToLong(s_2.z4i_1), fromIndex_0), offset_6));
-              while (pos_1 < limit_1) {
-                if (data_1[pos_1] === b) {
-                  tmp$ret$2 = add(numberToLong(pos_1 - s_2.z4i_1 | 0), offset_6);
-                  break $l$block_8;
+              var offset_4 = new (Long())(0, 0);
+              $l$loop: while (true) {
+                var tmp0_2 = offset_4;
+                // Inline function 'kotlin.Long.plus' call
+                var other = s_0.i4j_1 - s_0.h4j_1 | 0;
+                var nextOffset = add(tmp0_2, fromInt(other));
+                if (compare(nextOffset, tmp2) > 0)
+                  break $l$loop;
+                s_0 = ensureNotNull(s_0.l4j_1);
+                offset_4 = nextOffset;
+              }
+              var tmp0_3 = s_0;
+              var offset_5 = offset_4;
+              var tmp_2;
+              if (tmp0_3 == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_10;
+              } else {
+                tmp_2 = tmp0_3;
+              }
+              var s_2 = tmp_2;
+              var offset_6 = offset_5;
+              while (compare(offset_6, toIndex_0) < 0) {
+                var data_1 = s_2.g4j_1;
+                var tmp0_4 = fromInt(s_2.i4j_1);
+                // Inline function 'kotlin.comparisons.minOf' call
+                var b_2 = subtract(add(numberToLong(s_2.h4j_1), toIndex_0), offset_6);
+                var tmp$ret$10 = compare(tmp0_4, b_2) <= 0 ? tmp0_4 : b_2;
+                var limit_1 = convertToInt(tmp$ret$10);
+                var pos_1 = convertToInt(subtract(add(numberToLong(s_2.h4j_1), fromIndex_0), offset_6));
+                while (pos_1 < limit_1) {
+                  if (data_1[pos_1] === b) {
+                    tmp$ret$0 = add(numberToLong(pos_1 - s_2.h4j_1 | 0), offset_6);
+                    break $l$block_10;
+                  }
+                  pos_1 = pos_1 + 1 | 0;
                 }
-                pos_1 = pos_1 + 1 | 0;
+                offset_6 = add(offset_6, fromInt(s_2.i4j_1 - s_2.h4j_1 | 0));
+                fromIndex_0 = offset_6;
+                s_2 = ensureNotNull(s_2.l4j_1);
               }
-              offset_6 = add(offset_6, fromInt(s_2.a4j_1 - s_2.z4i_1 | 0));
-              fromIndex_0 = offset_6;
-              s_2 = ensureNotNull(s_2.d4j_1);
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_10;
             }
-            tmp$ret$2 = new (Long())(-1, -1);
-            break $l$block_8;
           }
         }
-        return tmp$ret$2;
+        return tmp$ret$0;
       }
-      x4l(bytes) {
-        return this.y4l(bytes, new (Long())(0, 0));
+      f4m(bytes) {
+        return this.g4m(bytes, new (Long())(0, 0));
       }
-      y4l(bytes, fromIndex) {
-        var tmp$ret$4;
-        $l$block_7: {
+      g4m(bytes, fromIndex) {
+        var tmp$ret$0;
+        $l$block_9: {
           // Inline function 'okio.internal.commonIndexOf' call
           var fromIndex_0 = fromIndex;
           // Inline function 'kotlin.require' call
-          if (!(bytes.v2() > 0)) {
+          if (!(bytes.q2() > 0)) {
             var message = 'bytes is empty';
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
           // Inline function 'kotlin.require' call
           if (!(compare(fromIndex_0, new (Long())(0, 0)) >= 0)) {
             var message_0 = 'fromIndex < 0: ' + fromIndex_0.toString();
-            throw IllegalArgumentException().r2(toString(message_0));
+            throw IllegalArgumentException().m2(toString(message_0));
           }
-          // Inline function 'okio.internal.seek' call
-          var fromIndex_1 = fromIndex_0;
-          var tmp0_elvis_lhs = this.j4i_1;
-          var tmp;
-          if (tmp0_elvis_lhs == null) {
-            var offset = new (Long())(-1, -1);
-            var tmp_0;
-            if (null == null) {
-              tmp$ret$4 = new (Long())(-1, -1);
-              break $l$block_7;
-            } else {
-              tmp_0 = null;
-            }
-            var s = tmp_0;
-            var offset_0 = offset;
-            var targetByteArray = bytes.h4k();
-            var b0 = targetByteArray[0];
-            var bytesSize = bytes.v2();
-            // Inline function 'kotlin.Long.minus' call
-            var this_0 = this.k4i_1;
-            var tmp$ret$5 = subtract(this_0, fromInt(bytesSize));
-            var resultLimit = add(tmp$ret$5, new (Long())(1, 0));
-            while (compare(offset_0, resultLimit) < 0) {
-              var data = s.y4i_1;
-              var tmp0 = s.a4j_1;
-              // Inline function 'okio.minOf' call
-              var b = subtract(add(numberToLong(s.z4i_1), resultLimit), offset_0);
-              // Inline function 'kotlin.comparisons.minOf' call
-              var a = fromInt(tmp0);
-              var tmp$ret$7 = compare(a, b) <= 0 ? a : b;
-              var segmentLimit = convertToInt(tmp$ret$7);
-              var inductionVariable = convertToInt(subtract(add(numberToLong(s.z4i_1), fromIndex_0), offset_0));
-              if (inductionVariable < segmentLimit)
-                do {
-                  var pos = inductionVariable;
-                  inductionVariable = inductionVariable + 1 | 0;
-                  if (data[pos] === b0 && rangeEquals(s, pos + 1 | 0, targetByteArray, 1, bytesSize)) {
-                    tmp$ret$4 = add(numberToLong(pos - s.z4i_1 | 0), offset_0);
-                    break $l$block_7;
+          var tmp2 = fromIndex_0;
+          $l$block_10: {
+            // Inline function 'okio.internal.seek' call
+            var tmp0_elvis_lhs = this.r4i_1;
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var offset = new (Long())(-1, -1);
+              var tmp_0;
+              if (null == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_9;
+              } else {
+                tmp_0 = null;
+              }
+              var s = tmp_0;
+              var offset_0 = offset;
+              var targetByteArray = bytes.p4k();
+              var b0 = targetByteArray[0];
+              var bytesSize = bytes.q2();
+              // Inline function 'kotlin.Long.minus' call
+              var this_0 = this.s4i_1;
+              var tmp$ret$7 = subtract(this_0, fromInt(bytesSize));
+              var resultLimit = add(tmp$ret$7, new (Long())(1, 0));
+              while (compare(offset_0, resultLimit) < 0) {
+                var data = s.g4j_1;
+                var tmp0 = s.i4j_1;
+                // Inline function 'okio.minOf' call
+                var b = subtract(add(numberToLong(s.h4j_1), resultLimit), offset_0);
+                // Inline function 'kotlin.comparisons.minOf' call
+                var a = fromInt(tmp0);
+                var tmp$ret$8 = compare(a, b) <= 0 ? a : b;
+                var segmentLimit = convertToInt(tmp$ret$8);
+                var inductionVariable = convertToInt(subtract(add(numberToLong(s.h4j_1), fromIndex_0), offset_0));
+                if (inductionVariable < segmentLimit)
+                  do {
+                    var pos = inductionVariable;
+                    inductionVariable = inductionVariable + 1 | 0;
+                    if (data[pos] === b0 && rangeEquals(s, pos + 1 | 0, targetByteArray, 1, bytesSize)) {
+                      tmp$ret$0 = add(numberToLong(pos - s.h4j_1 | 0), offset_0);
+                      break $l$block_9;
+                    }
                   }
-                }
-                 while (inductionVariable < segmentLimit);
-              offset_0 = add(offset_0, fromInt(s.a4j_1 - s.z4i_1 | 0));
-              fromIndex_0 = offset_0;
-              s = ensureNotNull(s.d4j_1);
-            }
-            tmp$ret$4 = new (Long())(-1, -1);
-            break $l$block_7;
-          } else {
-            tmp = tmp0_elvis_lhs;
-          }
-          var s_0 = tmp;
-          if (compare(subtract(this.k4i_1, fromIndex_1), fromIndex_1) < 0) {
-            var offset_1 = this.k4i_1;
-            while (compare(offset_1, fromIndex_1) > 0) {
-              s_0 = ensureNotNull(s_0.e4j_1);
-              offset_1 = subtract(offset_1, fromInt(s_0.a4j_1 - s_0.z4i_1 | 0));
-            }
-            var tmp0_0 = s_0;
-            var offset_2 = offset_1;
-            var tmp_1;
-            if (tmp0_0 == null) {
-              tmp$ret$4 = new (Long())(-1, -1);
-              break $l$block_7;
+                   while (inductionVariable < segmentLimit);
+                offset_0 = add(offset_0, fromInt(s.i4j_1 - s.h4j_1 | 0));
+                fromIndex_0 = offset_0;
+                s = ensureNotNull(s.l4j_1);
+              }
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_9;
             } else {
-              tmp_1 = tmp0_0;
+              tmp = tmp0_elvis_lhs;
             }
-            var s_1 = tmp_1;
-            var offset_3 = offset_2;
-            var targetByteArray_0 = bytes.h4k();
-            var b0_0 = targetByteArray_0[0];
-            var bytesSize_0 = bytes.v2();
-            // Inline function 'kotlin.Long.minus' call
-            var this_1 = this.k4i_1;
-            var tmp$ret$9 = subtract(this_1, fromInt(bytesSize_0));
-            var resultLimit_0 = add(tmp$ret$9, new (Long())(1, 0));
-            while (compare(offset_3, resultLimit_0) < 0) {
-              var data_0 = s_1.y4i_1;
-              var tmp0_1 = s_1.a4j_1;
-              // Inline function 'okio.minOf' call
-              var b_0 = subtract(add(numberToLong(s_1.z4i_1), resultLimit_0), offset_3);
-              // Inline function 'kotlin.comparisons.minOf' call
-              var a_0 = fromInt(tmp0_1);
-              var tmp$ret$11 = compare(a_0, b_0) <= 0 ? a_0 : b_0;
-              var segmentLimit_0 = convertToInt(tmp$ret$11);
-              var inductionVariable_0 = convertToInt(subtract(add(numberToLong(s_1.z4i_1), fromIndex_0), offset_3));
-              if (inductionVariable_0 < segmentLimit_0)
-                do {
-                  var pos_0 = inductionVariable_0;
-                  inductionVariable_0 = inductionVariable_0 + 1 | 0;
-                  if (data_0[pos_0] === b0_0 && rangeEquals(s_1, pos_0 + 1 | 0, targetByteArray_0, 1, bytesSize_0)) {
-                    tmp$ret$4 = add(numberToLong(pos_0 - s_1.z4i_1 | 0), offset_3);
-                    break $l$block_7;
+            var s_0 = tmp;
+            if (compare(subtract(this.s4i_1, tmp2), tmp2) < 0) {
+              var offset_1 = this.s4i_1;
+              while (compare(offset_1, tmp2) > 0) {
+                s_0 = ensureNotNull(s_0.m4j_1);
+                offset_1 = subtract(offset_1, fromInt(s_0.i4j_1 - s_0.h4j_1 | 0));
+              }
+              var tmp0_0 = s_0;
+              var offset_2 = offset_1;
+              var tmp_1;
+              if (tmp0_0 == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_9;
+              } else {
+                tmp_1 = tmp0_0;
+              }
+              var s_1 = tmp_1;
+              var offset_3 = offset_2;
+              var targetByteArray_0 = bytes.p4k();
+              var b0_0 = targetByteArray_0[0];
+              var bytesSize_0 = bytes.q2();
+              // Inline function 'kotlin.Long.minus' call
+              var this_1 = this.s4i_1;
+              var tmp$ret$11 = subtract(this_1, fromInt(bytesSize_0));
+              var resultLimit_0 = add(tmp$ret$11, new (Long())(1, 0));
+              while (compare(offset_3, resultLimit_0) < 0) {
+                var data_0 = s_1.g4j_1;
+                var tmp0_1 = s_1.i4j_1;
+                // Inline function 'okio.minOf' call
+                var b_0 = subtract(add(numberToLong(s_1.h4j_1), resultLimit_0), offset_3);
+                // Inline function 'kotlin.comparisons.minOf' call
+                var a_0 = fromInt(tmp0_1);
+                var tmp$ret$12 = compare(a_0, b_0) <= 0 ? a_0 : b_0;
+                var segmentLimit_0 = convertToInt(tmp$ret$12);
+                var inductionVariable_0 = convertToInt(subtract(add(numberToLong(s_1.h4j_1), fromIndex_0), offset_3));
+                if (inductionVariable_0 < segmentLimit_0)
+                  do {
+                    var pos_0 = inductionVariable_0;
+                    inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                    if (data_0[pos_0] === b0_0 && rangeEquals(s_1, pos_0 + 1 | 0, targetByteArray_0, 1, bytesSize_0)) {
+                      tmp$ret$0 = add(numberToLong(pos_0 - s_1.h4j_1 | 0), offset_3);
+                      break $l$block_9;
+                    }
                   }
-                }
-                 while (inductionVariable_0 < segmentLimit_0);
-              offset_3 = add(offset_3, fromInt(s_1.a4j_1 - s_1.z4i_1 | 0));
-              fromIndex_0 = offset_3;
-              s_1 = ensureNotNull(s_1.d4j_1);
-            }
-            tmp$ret$4 = new (Long())(-1, -1);
-            break $l$block_7;
-          } else {
-            var offset_4 = new (Long())(0, 0);
-            $l$loop: while (true) {
-              var tmp0_2 = offset_4;
-              // Inline function 'kotlin.Long.plus' call
-              var other = s_0.a4j_1 - s_0.z4i_1 | 0;
-              var nextOffset = add(tmp0_2, fromInt(other));
-              if (compare(nextOffset, fromIndex_1) > 0)
-                break $l$loop;
-              s_0 = ensureNotNull(s_0.d4j_1);
-              offset_4 = nextOffset;
-            }
-            var tmp0_3 = s_0;
-            var offset_5 = offset_4;
-            var tmp_2;
-            if (tmp0_3 == null) {
-              tmp$ret$4 = new (Long())(-1, -1);
-              break $l$block_7;
+                   while (inductionVariable_0 < segmentLimit_0);
+                offset_3 = add(offset_3, fromInt(s_1.i4j_1 - s_1.h4j_1 | 0));
+                fromIndex_0 = offset_3;
+                s_1 = ensureNotNull(s_1.l4j_1);
+              }
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_9;
             } else {
-              tmp_2 = tmp0_3;
-            }
-            var s_2 = tmp_2;
-            var offset_6 = offset_5;
-            var targetByteArray_1 = bytes.h4k();
-            var b0_1 = targetByteArray_1[0];
-            var bytesSize_1 = bytes.v2();
-            // Inline function 'kotlin.Long.minus' call
-            var this_2 = this.k4i_1;
-            var tmp$ret$13 = subtract(this_2, fromInt(bytesSize_1));
-            var resultLimit_1 = add(tmp$ret$13, new (Long())(1, 0));
-            while (compare(offset_6, resultLimit_1) < 0) {
-              var data_1 = s_2.y4i_1;
-              var tmp0_4 = s_2.a4j_1;
-              // Inline function 'okio.minOf' call
-              var b_1 = subtract(add(numberToLong(s_2.z4i_1), resultLimit_1), offset_6);
-              // Inline function 'kotlin.comparisons.minOf' call
-              var a_1 = fromInt(tmp0_4);
-              var tmp$ret$15 = compare(a_1, b_1) <= 0 ? a_1 : b_1;
-              var segmentLimit_1 = convertToInt(tmp$ret$15);
-              var inductionVariable_1 = convertToInt(subtract(add(numberToLong(s_2.z4i_1), fromIndex_0), offset_6));
-              if (inductionVariable_1 < segmentLimit_1)
-                do {
-                  var pos_1 = inductionVariable_1;
-                  inductionVariable_1 = inductionVariable_1 + 1 | 0;
-                  if (data_1[pos_1] === b0_1 && rangeEquals(s_2, pos_1 + 1 | 0, targetByteArray_1, 1, bytesSize_1)) {
-                    tmp$ret$4 = add(numberToLong(pos_1 - s_2.z4i_1 | 0), offset_6);
-                    break $l$block_7;
+              var offset_4 = new (Long())(0, 0);
+              $l$loop: while (true) {
+                var tmp0_2 = offset_4;
+                // Inline function 'kotlin.Long.plus' call
+                var other = s_0.i4j_1 - s_0.h4j_1 | 0;
+                var nextOffset = add(tmp0_2, fromInt(other));
+                if (compare(nextOffset, tmp2) > 0)
+                  break $l$loop;
+                s_0 = ensureNotNull(s_0.l4j_1);
+                offset_4 = nextOffset;
+              }
+              var tmp0_3 = s_0;
+              var offset_5 = offset_4;
+              var tmp_2;
+              if (tmp0_3 == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_9;
+              } else {
+                tmp_2 = tmp0_3;
+              }
+              var s_2 = tmp_2;
+              var offset_6 = offset_5;
+              var targetByteArray_1 = bytes.p4k();
+              var b0_1 = targetByteArray_1[0];
+              var bytesSize_1 = bytes.q2();
+              // Inline function 'kotlin.Long.minus' call
+              var this_2 = this.s4i_1;
+              var tmp$ret$16 = subtract(this_2, fromInt(bytesSize_1));
+              var resultLimit_1 = add(tmp$ret$16, new (Long())(1, 0));
+              while (compare(offset_6, resultLimit_1) < 0) {
+                var data_1 = s_2.g4j_1;
+                var tmp0_4 = s_2.i4j_1;
+                // Inline function 'okio.minOf' call
+                var b_1 = subtract(add(numberToLong(s_2.h4j_1), resultLimit_1), offset_6);
+                // Inline function 'kotlin.comparisons.minOf' call
+                var a_1 = fromInt(tmp0_4);
+                var tmp$ret$17 = compare(a_1, b_1) <= 0 ? a_1 : b_1;
+                var segmentLimit_1 = convertToInt(tmp$ret$17);
+                var inductionVariable_1 = convertToInt(subtract(add(numberToLong(s_2.h4j_1), fromIndex_0), offset_6));
+                if (inductionVariable_1 < segmentLimit_1)
+                  do {
+                    var pos_1 = inductionVariable_1;
+                    inductionVariable_1 = inductionVariable_1 + 1 | 0;
+                    if (data_1[pos_1] === b0_1 && rangeEquals(s_2, pos_1 + 1 | 0, targetByteArray_1, 1, bytesSize_1)) {
+                      tmp$ret$0 = add(numberToLong(pos_1 - s_2.h4j_1 | 0), offset_6);
+                      break $l$block_9;
+                    }
                   }
-                }
-                 while (inductionVariable_1 < segmentLimit_1);
-              offset_6 = add(offset_6, fromInt(s_2.a4j_1 - s_2.z4i_1 | 0));
-              fromIndex_0 = offset_6;
-              s_2 = ensureNotNull(s_2.d4j_1);
+                   while (inductionVariable_1 < segmentLimit_1);
+                offset_6 = add(offset_6, fromInt(s_2.i4j_1 - s_2.h4j_1 | 0));
+                fromIndex_0 = offset_6;
+                s_2 = ensureNotNull(s_2.l4j_1);
+              }
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_9;
             }
-            tmp$ret$4 = new (Long())(-1, -1);
-            break $l$block_7;
           }
         }
-        return tmp$ret$4;
+        return tmp$ret$0;
       }
-      z4l(targetBytes) {
-        return this.a4m(targetBytes, new (Long())(0, 0));
+      h4m(targetBytes) {
+        return this.i4m(targetBytes, new (Long())(0, 0));
       }
-      a4m(targetBytes, fromIndex) {
-        var tmp$ret$2;
-        $l$block_10: {
+      i4m(targetBytes, fromIndex) {
+        var tmp$ret$0;
+        $l$block_12: {
           // Inline function 'okio.internal.commonIndexOfElement' call
           var fromIndex_0 = fromIndex;
           // Inline function 'kotlin.require' call
           if (!(compare(fromIndex_0, new (Long())(0, 0)) >= 0)) {
             var message = 'fromIndex < 0: ' + fromIndex_0.toString();
-            throw IllegalArgumentException().r2(toString(message));
+            throw IllegalArgumentException().m2(toString(message));
           }
-          // Inline function 'okio.internal.seek' call
-          var fromIndex_1 = fromIndex_0;
-          var tmp0_elvis_lhs = this.j4i_1;
-          var tmp;
-          if (tmp0_elvis_lhs == null) {
-            var offset = new (Long())(-1, -1);
-            var tmp_0;
-            if (null == null) {
-              tmp$ret$2 = new (Long())(-1, -1);
-              break $l$block_10;
-            } else {
-              tmp_0 = null;
-            }
-            var s = tmp_0;
-            var offset_0 = offset;
-            if (targetBytes.v2() === 2) {
-              var b0 = targetBytes.u2(0);
-              var b1 = targetBytes.u2(1);
-              while (compare(offset_0, this.k4i_1) < 0) {
-                var data = s.y4i_1;
-                var pos = convertToInt(subtract(add(numberToLong(s.z4i_1), fromIndex_0), offset_0));
-                var limit = s.a4j_1;
-                while (pos < limit) {
-                  var b = data[pos];
-                  if (b === b0 || b === b1) {
-                    tmp$ret$2 = add(numberToLong(pos - s.z4i_1 | 0), offset_0);
-                    break $l$block_10;
+          var tmp2 = fromIndex_0;
+          $l$block_13: {
+            // Inline function 'okio.internal.seek' call
+            var tmp0_elvis_lhs = this.r4i_1;
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              var offset = new (Long())(-1, -1);
+              var tmp_0;
+              if (null == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_12;
+              } else {
+                tmp_0 = null;
+              }
+              var s = tmp_0;
+              var offset_0 = offset;
+              if (targetBytes.q2() === 2) {
+                var b0 = targetBytes.p2(0);
+                var b1 = targetBytes.p2(1);
+                while (compare(offset_0, this.s4i_1) < 0) {
+                  var data = s.g4j_1;
+                  var pos = convertToInt(subtract(add(numberToLong(s.h4j_1), fromIndex_0), offset_0));
+                  var limit = s.i4j_1;
+                  while (pos < limit) {
+                    var b = data[pos];
+                    if (b === b0 || b === b1) {
+                      tmp$ret$0 = add(numberToLong(pos - s.h4j_1 | 0), offset_0);
+                      break $l$block_12;
+                    }
+                    pos = pos + 1 | 0;
                   }
-                  pos = pos + 1 | 0;
+                  offset_0 = add(offset_0, fromInt(s.i4j_1 - s.h4j_1 | 0));
+                  fromIndex_0 = offset_0;
+                  s = ensureNotNull(s.l4j_1);
                 }
-                offset_0 = add(offset_0, fromInt(s.a4j_1 - s.z4i_1 | 0));
-                fromIndex_0 = offset_0;
-                s = ensureNotNull(s.d4j_1);
-              }
-            } else {
-              var targetByteArray = targetBytes.h4k();
-              while (compare(offset_0, this.k4i_1) < 0) {
-                var data_0 = s.y4i_1;
-                var pos_0 = convertToInt(subtract(add(numberToLong(s.z4i_1), fromIndex_0), offset_0));
-                var limit_0 = s.a4j_1;
-                while (pos_0 < limit_0) {
-                  var b_0 = data_0[pos_0];
-                  var inductionVariable = 0;
-                  var last = targetByteArray.length;
-                  while (inductionVariable < last) {
-                    var t = targetByteArray[inductionVariable];
-                    inductionVariable = inductionVariable + 1 | 0;
-                    if (b_0 === t) {
-                      tmp$ret$2 = add(numberToLong(pos_0 - s.z4i_1 | 0), offset_0);
-                      break $l$block_10;
+              } else {
+                var targetByteArray = targetBytes.p4k();
+                while (compare(offset_0, this.s4i_1) < 0) {
+                  var data_0 = s.g4j_1;
+                  var pos_0 = convertToInt(subtract(add(numberToLong(s.h4j_1), fromIndex_0), offset_0));
+                  var limit_0 = s.i4j_1;
+                  while (pos_0 < limit_0) {
+                    var b_0 = data_0[pos_0];
+                    var inductionVariable = 0;
+                    var last = targetByteArray.length;
+                    while (inductionVariable < last) {
+                      var t = targetByteArray[inductionVariable];
+                      inductionVariable = inductionVariable + 1 | 0;
+                      if (b_0 === t) {
+                        tmp$ret$0 = add(numberToLong(pos_0 - s.h4j_1 | 0), offset_0);
+                        break $l$block_12;
+                      }
                     }
+                    pos_0 = pos_0 + 1 | 0;
                   }
-                  pos_0 = pos_0 + 1 | 0;
+                  offset_0 = add(offset_0, fromInt(s.i4j_1 - s.h4j_1 | 0));
+                  fromIndex_0 = offset_0;
+                  s = ensureNotNull(s.l4j_1);
                 }
-                offset_0 = add(offset_0, fromInt(s.a4j_1 - s.z4i_1 | 0));
-                fromIndex_0 = offset_0;
-                s = ensureNotNull(s.d4j_1);
               }
-            }
-            tmp$ret$2 = new (Long())(-1, -1);
-            break $l$block_10;
-          } else {
-            tmp = tmp0_elvis_lhs;
-          }
-          var s_0 = tmp;
-          if (compare(subtract(this.k4i_1, fromIndex_1), fromIndex_1) < 0) {
-            var offset_1 = this.k4i_1;
-            while (compare(offset_1, fromIndex_1) > 0) {
-              s_0 = ensureNotNull(s_0.e4j_1);
-              offset_1 = subtract(offset_1, fromInt(s_0.a4j_1 - s_0.z4i_1 | 0));
-            }
-            var tmp0 = s_0;
-            var offset_2 = offset_1;
-            var tmp_1;
-            if (tmp0 == null) {
-              tmp$ret$2 = new (Long())(-1, -1);
-              break $l$block_10;
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_12;
             } else {
-              tmp_1 = tmp0;
+              tmp = tmp0_elvis_lhs;
             }
-            var s_1 = tmp_1;
-            var offset_3 = offset_2;
-            if (targetBytes.v2() === 2) {
-              var b0_0 = targetBytes.u2(0);
-              var b1_0 = targetBytes.u2(1);
-              while (compare(offset_3, this.k4i_1) < 0) {
-                var data_1 = s_1.y4i_1;
-                var pos_1 = convertToInt(subtract(add(numberToLong(s_1.z4i_1), fromIndex_0), offset_3));
-                var limit_1 = s_1.a4j_1;
-                while (pos_1 < limit_1) {
-                  var b_1 = data_1[pos_1];
-                  if (b_1 === b0_0 || b_1 === b1_0) {
-                    tmp$ret$2 = add(numberToLong(pos_1 - s_1.z4i_1 | 0), offset_3);
-                    break $l$block_10;
+            var s_0 = tmp;
+            if (compare(subtract(this.s4i_1, tmp2), tmp2) < 0) {
+              var offset_1 = this.s4i_1;
+              while (compare(offset_1, tmp2) > 0) {
+                s_0 = ensureNotNull(s_0.m4j_1);
+                offset_1 = subtract(offset_1, fromInt(s_0.i4j_1 - s_0.h4j_1 | 0));
+              }
+              var tmp0 = s_0;
+              var offset_2 = offset_1;
+              var tmp_1;
+              if (tmp0 == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_12;
+              } else {
+                tmp_1 = tmp0;
+              }
+              var s_1 = tmp_1;
+              var offset_3 = offset_2;
+              if (targetBytes.q2() === 2) {
+                var b0_0 = targetBytes.p2(0);
+                var b1_0 = targetBytes.p2(1);
+                while (compare(offset_3, this.s4i_1) < 0) {
+                  var data_1 = s_1.g4j_1;
+                  var pos_1 = convertToInt(subtract(add(numberToLong(s_1.h4j_1), fromIndex_0), offset_3));
+                  var limit_1 = s_1.i4j_1;
+                  while (pos_1 < limit_1) {
+                    var b_1 = data_1[pos_1];
+                    if (b_1 === b0_0 || b_1 === b1_0) {
+                      tmp$ret$0 = add(numberToLong(pos_1 - s_1.h4j_1 | 0), offset_3);
+                      break $l$block_12;
+                    }
+                    pos_1 = pos_1 + 1 | 0;
                   }
-                  pos_1 = pos_1 + 1 | 0;
+                  offset_3 = add(offset_3, fromInt(s_1.i4j_1 - s_1.h4j_1 | 0));
+                  fromIndex_0 = offset_3;
+                  s_1 = ensureNotNull(s_1.l4j_1);
                 }
-                offset_3 = add(offset_3, fromInt(s_1.a4j_1 - s_1.z4i_1 | 0));
-                fromIndex_0 = offset_3;
-                s_1 = ensureNotNull(s_1.d4j_1);
-              }
-            } else {
-              var targetByteArray_0 = targetBytes.h4k();
-              while (compare(offset_3, this.k4i_1) < 0) {
-                var data_2 = s_1.y4i_1;
-                var pos_2 = convertToInt(subtract(add(numberToLong(s_1.z4i_1), fromIndex_0), offset_3));
-                var limit_2 = s_1.a4j_1;
-                while (pos_2 < limit_2) {
-                  var b_2 = data_2[pos_2];
-                  var inductionVariable_0 = 0;
-                  var last_0 = targetByteArray_0.length;
-                  while (inductionVariable_0 < last_0) {
-                    var t_0 = targetByteArray_0[inductionVariable_0];
-                    inductionVariable_0 = inductionVariable_0 + 1 | 0;
-                    if (b_2 === t_0) {
-                      tmp$ret$2 = add(numberToLong(pos_2 - s_1.z4i_1 | 0), offset_3);
-                      break $l$block_10;
+              } else {
+                var targetByteArray_0 = targetBytes.p4k();
+                while (compare(offset_3, this.s4i_1) < 0) {
+                  var data_2 = s_1.g4j_1;
+                  var pos_2 = convertToInt(subtract(add(numberToLong(s_1.h4j_1), fromIndex_0), offset_3));
+                  var limit_2 = s_1.i4j_1;
+                  while (pos_2 < limit_2) {
+                    var b_2 = data_2[pos_2];
+                    var inductionVariable_0 = 0;
+                    var last_0 = targetByteArray_0.length;
+                    while (inductionVariable_0 < last_0) {
+                      var t_0 = targetByteArray_0[inductionVariable_0];
+                      inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                      if (b_2 === t_0) {
+                        tmp$ret$0 = add(numberToLong(pos_2 - s_1.h4j_1 | 0), offset_3);
+                        break $l$block_12;
+                      }
                     }
+                    pos_2 = pos_2 + 1 | 0;
                   }
-                  pos_2 = pos_2 + 1 | 0;
+                  offset_3 = add(offset_3, fromInt(s_1.i4j_1 - s_1.h4j_1 | 0));
+                  fromIndex_0 = offset_3;
+                  s_1 = ensureNotNull(s_1.l4j_1);
                 }
-                offset_3 = add(offset_3, fromInt(s_1.a4j_1 - s_1.z4i_1 | 0));
-                fromIndex_0 = offset_3;
-                s_1 = ensureNotNull(s_1.d4j_1);
               }
-            }
-            tmp$ret$2 = new (Long())(-1, -1);
-            break $l$block_10;
-          } else {
-            var offset_4 = new (Long())(0, 0);
-            $l$loop: while (true) {
-              var tmp0_0 = offset_4;
-              // Inline function 'kotlin.Long.plus' call
-              var other = s_0.a4j_1 - s_0.z4i_1 | 0;
-              var nextOffset = add(tmp0_0, fromInt(other));
-              if (compare(nextOffset, fromIndex_1) > 0)
-                break $l$loop;
-              s_0 = ensureNotNull(s_0.d4j_1);
-              offset_4 = nextOffset;
-            }
-            var tmp0_1 = s_0;
-            var offset_5 = offset_4;
-            var tmp_2;
-            if (tmp0_1 == null) {
-              tmp$ret$2 = new (Long())(-1, -1);
-              break $l$block_10;
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_12;
             } else {
-              tmp_2 = tmp0_1;
-            }
-            var s_2 = tmp_2;
-            var offset_6 = offset_5;
-            if (targetBytes.v2() === 2) {
-              var b0_1 = targetBytes.u2(0);
-              var b1_1 = targetBytes.u2(1);
-              while (compare(offset_6, this.k4i_1) < 0) {
-                var data_3 = s_2.y4i_1;
-                var pos_3 = convertToInt(subtract(add(numberToLong(s_2.z4i_1), fromIndex_0), offset_6));
-                var limit_3 = s_2.a4j_1;
-                while (pos_3 < limit_3) {
-                  var b_3 = data_3[pos_3];
-                  if (b_3 === b0_1 || b_3 === b1_1) {
-                    tmp$ret$2 = add(numberToLong(pos_3 - s_2.z4i_1 | 0), offset_6);
-                    break $l$block_10;
+              var offset_4 = new (Long())(0, 0);
+              $l$loop: while (true) {
+                var tmp0_0 = offset_4;
+                // Inline function 'kotlin.Long.plus' call
+                var other = s_0.i4j_1 - s_0.h4j_1 | 0;
+                var nextOffset = add(tmp0_0, fromInt(other));
+                if (compare(nextOffset, tmp2) > 0)
+                  break $l$loop;
+                s_0 = ensureNotNull(s_0.l4j_1);
+                offset_4 = nextOffset;
+              }
+              var tmp0_1 = s_0;
+              var offset_5 = offset_4;
+              var tmp_2;
+              if (tmp0_1 == null) {
+                tmp$ret$0 = new (Long())(-1, -1);
+                break $l$block_12;
+              } else {
+                tmp_2 = tmp0_1;
+              }
+              var s_2 = tmp_2;
+              var offset_6 = offset_5;
+              if (targetBytes.q2() === 2) {
+                var b0_1 = targetBytes.p2(0);
+                var b1_1 = targetBytes.p2(1);
+                while (compare(offset_6, this.s4i_1) < 0) {
+                  var data_3 = s_2.g4j_1;
+                  var pos_3 = convertToInt(subtract(add(numberToLong(s_2.h4j_1), fromIndex_0), offset_6));
+                  var limit_3 = s_2.i4j_1;
+                  while (pos_3 < limit_3) {
+                    var b_3 = data_3[pos_3];
+                    if (b_3 === b0_1 || b_3 === b1_1) {
+                      tmp$ret$0 = add(numberToLong(pos_3 - s_2.h4j_1 | 0), offset_6);
+                      break $l$block_12;
+                    }
+                    pos_3 = pos_3 + 1 | 0;
                   }
-                  pos_3 = pos_3 + 1 | 0;
+                  offset_6 = add(offset_6, fromInt(s_2.i4j_1 - s_2.h4j_1 | 0));
+                  fromIndex_0 = offset_6;
+                  s_2 = ensureNotNull(s_2.l4j_1);
                 }
-                offset_6 = add(offset_6, fromInt(s_2.a4j_1 - s_2.z4i_1 | 0));
-                fromIndex_0 = offset_6;
-                s_2 = ensureNotNull(s_2.d4j_1);
-              }
-            } else {
-              var targetByteArray_1 = targetBytes.h4k();
-              while (compare(offset_6, this.k4i_1) < 0) {
-                var data_4 = s_2.y4i_1;
-                var pos_4 = convertToInt(subtract(add(numberToLong(s_2.z4i_1), fromIndex_0), offset_6));
-                var limit_4 = s_2.a4j_1;
-                while (pos_4 < limit_4) {
-                  var b_4 = data_4[pos_4];
-                  var inductionVariable_1 = 0;
-                  var last_1 = targetByteArray_1.length;
-                  while (inductionVariable_1 < last_1) {
-                    var t_1 = targetByteArray_1[inductionVariable_1];
-                    inductionVariable_1 = inductionVariable_1 + 1 | 0;
-                    if (b_4 === t_1) {
-                      tmp$ret$2 = add(numberToLong(pos_4 - s_2.z4i_1 | 0), offset_6);
-                      break $l$block_10;
+              } else {
+                var targetByteArray_1 = targetBytes.p4k();
+                while (compare(offset_6, this.s4i_1) < 0) {
+                  var data_4 = s_2.g4j_1;
+                  var pos_4 = convertToInt(subtract(add(numberToLong(s_2.h4j_1), fromIndex_0), offset_6));
+                  var limit_4 = s_2.i4j_1;
+                  while (pos_4 < limit_4) {
+                    var b_4 = data_4[pos_4];
+                    var inductionVariable_1 = 0;
+                    var last_1 = targetByteArray_1.length;
+                    while (inductionVariable_1 < last_1) {
+                      var t_1 = targetByteArray_1[inductionVariable_1];
+                      inductionVariable_1 = inductionVariable_1 + 1 | 0;
+                      if (b_4 === t_1) {
+                        tmp$ret$0 = add(numberToLong(pos_4 - s_2.h4j_1 | 0), offset_6);
+                        break $l$block_12;
+                      }
                     }
+                    pos_4 = pos_4 + 1 | 0;
                   }
-                  pos_4 = pos_4 + 1 | 0;
+                  offset_6 = add(offset_6, fromInt(s_2.i4j_1 - s_2.h4j_1 | 0));
+                  fromIndex_0 = offset_6;
+                  s_2 = ensureNotNull(s_2.l4j_1);
                 }
-                offset_6 = add(offset_6, fromInt(s_2.a4j_1 - s_2.z4i_1 | 0));
-                fromIndex_0 = offset_6;
-                s_2 = ensureNotNull(s_2.d4j_1);
               }
+              tmp$ret$0 = new (Long())(-1, -1);
+              break $l$block_12;
             }
-            tmp$ret$2 = new (Long())(-1, -1);
-            break $l$block_10;
           }
         }
-        return tmp$ret$2;
+        return tmp$ret$0;
       }
-      b4m(offset, bytes) {
-        return this.c4m(offset, bytes, 0, bytes.v2());
+      j4m(offset, bytes) {
+        return this.k4m(offset, bytes, 0, bytes.q2());
       }
-      c4m(offset, bytes, bytesOffset, byteCount) {
+      k4m(offset, bytes, bytesOffset, byteCount) {
         var tmp$ret$0;
         $l$block_0: {
           // Inline function 'okio.internal.commonRangeEquals' call
-          if (compare(offset, new (Long())(0, 0)) < 0 || bytesOffset < 0 || byteCount < 0 || compare(subtract(this.k4i_1, offset), fromInt(byteCount)) < 0 || (bytes.v2() - bytesOffset | 0) < byteCount) {
+          if (compare(offset, new (Long())(0, 0)) < 0 || bytesOffset < 0 || byteCount < 0 || compare(subtract(this.s4i_1, offset), fromInt(byteCount)) < 0 || (bytes.q2() - bytesOffset | 0) < byteCount) {
             tmp$ret$0 = false;
             break $l$block_0;
           }
@@ -1342,7 +1350,7 @@ function Buffer() {
               inductionVariable = inductionVariable + 1 | 0;
               // Inline function 'kotlin.Long.plus' call
               var tmp$ret$1 = add(offset, fromInt(i));
-              if (!(this.d1q(tmp$ret$1) === bytes.u2(bytesOffset + i | 0))) {
+              if (!(this.y1p(tmp$ret$1) === bytes.p2(bytesOffset + i | 0))) {
                 tmp$ret$0 = false;
                 break $l$block_0;
               }
@@ -1352,10 +1360,10 @@ function Buffer() {
         }
         return tmp$ret$0;
       }
-      ad() {
+      vc() {
         return Unit_instance;
       }
-      o6() {
+      j6() {
         return Unit_instance;
       }
       equals(other) {
@@ -1370,24 +1378,24 @@ function Buffer() {
             tmp$ret$0 = false;
             break $l$block_3;
           }
-          if (!equalsLong(this.k4i_1, other.k4i_1)) {
+          if (!equalsLong(this.s4i_1, other.s4i_1)) {
             tmp$ret$0 = false;
             break $l$block_3;
           }
-          if (equalsLong(this.k4i_1, new (Long())(0, 0))) {
+          if (equalsLong(this.s4i_1, new (Long())(0, 0))) {
             tmp$ret$0 = true;
             break $l$block_3;
           }
-          var sa = ensureNotNull(this.j4i_1);
-          var sb = ensureNotNull(other.j4i_1);
-          var posA = sa.z4i_1;
-          var posB = sb.z4i_1;
+          var sa = ensureNotNull(this.r4i_1);
+          var sb = ensureNotNull(other.r4i_1);
+          var posA = sa.h4j_1;
+          var posB = sb.h4j_1;
           var pos = new (Long())(0, 0);
           var count;
-          while (compare(pos, this.k4i_1) < 0) {
-            var tmp0 = sa.a4j_1 - posA | 0;
+          while (compare(pos, this.s4i_1) < 0) {
+            var tmp0 = sa.i4j_1 - posA | 0;
             // Inline function 'kotlin.comparisons.minOf' call
-            var b = sb.a4j_1 - posB | 0;
+            var b = sb.i4j_1 - posB | 0;
             var tmp$ret$1 = Math.min(tmp0, b);
             count = fromInt(tmp$ret$1);
             var inductionVariable = new (Long())(0, 0);
@@ -1395,11 +1403,11 @@ function Buffer() {
               do {
                 var i = inductionVariable;
                 inductionVariable = add(inductionVariable, new (Long())(1, 0));
-                var tmp = sa.y4i_1;
+                var tmp = sa.g4j_1;
                 var tmp1 = posA;
                 posA = tmp1 + 1 | 0;
                 var tmp_0 = tmp[tmp1];
-                var tmp_1 = sb.y4i_1;
+                var tmp_1 = sb.g4j_1;
                 var tmp2 = posB;
                 posB = tmp2 + 1 | 0;
                 if (!(tmp_0 === tmp_1[tmp2])) {
@@ -1408,13 +1416,13 @@ function Buffer() {
                 }
               }
                while (compare(inductionVariable, count) < 0);
-            if (posA === sa.a4j_1) {
-              sa = ensureNotNull(sa.d4j_1);
-              posA = sa.z4i_1;
+            if (posA === sa.i4j_1) {
+              sa = ensureNotNull(sa.l4j_1);
+              posA = sa.h4j_1;
             }
-            if (posB === sb.a4j_1) {
-              sb = ensureNotNull(sb.d4j_1);
-              posB = sb.z4i_1;
+            if (posB === sb.i4j_1) {
+              sb = ensureNotNull(sb.l4j_1);
+              posB = sb.h4j_1;
             }
             pos = add(pos, count);
           }
@@ -1426,7 +1434,7 @@ function Buffer() {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonHashCode' call
-          var tmp0_elvis_lhs = this.j4i_1;
+          var tmp0_elvis_lhs = this.r4i_1;
           var tmp;
           if (tmp0_elvis_lhs == null) {
             tmp$ret$0 = 0;
@@ -1437,50 +1445,50 @@ function Buffer() {
           var s = tmp;
           var result = 1;
           do {
-            var pos = s.z4i_1;
-            var limit = s.a4j_1;
+            var pos = s.h4j_1;
+            var limit = s.i4j_1;
             while (pos < limit) {
-              result = imul(31, result) + s.y4i_1[pos] | 0;
+              result = imul(31, result) + s.g4j_1[pos] | 0;
               pos = pos + 1 | 0;
             }
-            s = ensureNotNull(s.d4j_1);
+            s = ensureNotNull(s.l4j_1);
           }
-           while (!(s === this.j4i_1));
+           while (!(s === this.r4i_1));
           tmp$ret$0 = result;
         }
         return tmp$ret$0;
       }
       toString() {
-        return this.d4m().toString();
+        return this.l4m().toString();
       }
-      d4m() {
+      l4m() {
         // Inline function 'okio.internal.commonSnapshot' call
         // Inline function 'kotlin.check' call
-        if (!(compare(this.k4i_1, new (Long())(2147483647, 0)) <= 0)) {
-          var message = 'size > Int.MAX_VALUE: ' + this.k4i_1.toString();
+        if (!(compare(this.s4i_1, new (Long())(2147483647, 0)) <= 0)) {
+          var message = 'size > Int.MAX_VALUE: ' + this.s4i_1.toString();
           throw IllegalStateException().o(toString(message));
         }
-        return this.h4l(convertToInt(this.k4i_1));
+        return this.p4l(convertToInt(this.s4i_1));
       }
-      h4l(byteCount) {
+      p4l(byteCount) {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonSnapshot' call
           if (byteCount === 0) {
-            tmp$ret$0 = Companion_getInstance().c4k_1;
+            tmp$ret$0 = Companion_getInstance().k4k_1;
             break $l$block;
           }
-          checkOffsetAndCount(this.k4i_1, new (Long())(0, 0), fromInt(byteCount));
+          checkOffsetAndCount(this.s4i_1, new (Long())(0, 0), fromInt(byteCount));
           var offset = 0;
           var segmentCount = 0;
-          var s = this.j4i_1;
+          var s = this.r4i_1;
           while (offset < byteCount) {
-            if (ensureNotNull(s).a4j_1 === s.z4i_1) {
-              throw AssertionError().if('s.limit == s.pos');
+            if (ensureNotNull(s).i4j_1 === s.h4j_1) {
+              throw AssertionError().bf('s.limit == s.pos');
             }
-            offset = offset + (s.a4j_1 - s.z4i_1 | 0) | 0;
+            offset = offset + (s.i4j_1 - s.h4j_1 | 0) | 0;
             segmentCount = segmentCount + 1 | 0;
-            s = s.d4j_1;
+            s = s.l4j_1;
           }
           // Inline function 'kotlin.arrayOfNulls' call
           var size = segmentCount;
@@ -1488,18 +1496,18 @@ function Buffer() {
           var directory = new Int32Array(imul(segmentCount, 2));
           offset = 0;
           segmentCount = 0;
-          s = this.j4i_1;
+          s = this.r4i_1;
           while (offset < byteCount) {
-            segments[segmentCount] = ensureNotNull(s).y4i_1;
-            offset = offset + (s.a4j_1 - s.z4i_1 | 0) | 0;
+            segments[segmentCount] = ensureNotNull(s).g4j_1;
+            offset = offset + (s.i4j_1 - s.h4j_1 | 0) | 0;
             var tmp = segmentCount;
             // Inline function 'kotlin.comparisons.minOf' call
             var a = offset;
             directory[tmp] = Math.min(a, byteCount);
-            directory[segmentCount + segments.length | 0] = s.z4i_1;
-            s.b4j_1 = true;
+            directory[segmentCount + segments.length | 0] = s.h4j_1;
+            s.j4j_1 = true;
             segmentCount = segmentCount + 1 | 0;
-            s = s.d4j_1;
+            s = s.l4j_1;
           }
           tmp$ret$0 = new (SegmentedByteString())(isArray(segments) ? segments : THROW_CCE(), directory);
         }