@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,1521 @@
+import { Long2qws0ah9gnpki as Long } from '../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import {
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  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 { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  equalsLong28bsrfhwvd686 as equalsLong,
+  compare2uud5j30pw5xc as compare,
+  add85si75olwt6n as add,
+  fromInt1lka3ktyu79a4 as fromInt,
+  subtract16cg4lfi29fq9 as subtract,
+  convertToIntofdoxh9bstof as convertToInt,
+  numberToLong345n6tb1n1i71 as numberToLong,
+} from '../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { EOFException34hypof9gkxss as EOFException } from './NonJvmPlatform.mjs';
+import { checkOffsetAndCount2b5icqlx5z1pu as checkOffsetAndCount } from './Util.mjs';
+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 {
+  ByteString2qc03wzjsovk as ByteString,
+  Companion_getInstance28gds36m4006o 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,
+} from '../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { toByte4i43936u611k as toByte } from '../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import {
+  readUtf8Line36yidw3sdfobh as readUtf8Line,
+  selectPrefix5tb3rl5iltlw as selectPrefix,
+  rangeEquals13q7f5dia0en as rangeEquals,
+} from './internal/Buffer.mjs';
+import { arrayCopytctsywo3h7gj as arrayCopy } from '../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import { charCodeAt1yspne1d8erbm as charCodeAt } from '../../kotlin-kotlin-stdlib/kotlin/js/charSequenceJs.mjs';
+import { isArray1hxjqtqy632bc as isArray } from '../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { SegmentedByteString5e5x58c4yl7l as SegmentedByteString } from './SegmentedByteString.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var UnsafeCursorClass;
+function UnsafeCursor() {
+  if (UnsafeCursorClass === VOID) {
+    class $ {
+      constructor() {
+        this.b4f_1 = null;
+        this.c4f_1 = false;
+        this.d4f_1 = null;
+        this.e4f_1 = new (Long())(-1, -1);
+        this.f4f_1 = null;
+        this.g4f_1 = -1;
+        this.h4f_1 = -1;
+      }
+      o6() {
+        // Inline function 'okio.internal.commonClose' call
+        // Inline function 'kotlin.check' call
+        if (!!(this.b4f_1 == null)) {
+          var message = 'not attached to a buffer';
+          throw IllegalStateException().o(toString(message));
+        }
+        this.b4f_1 = null;
+        this.d4f_1 = null;
+        this.e4f_1 = new (Long())(-1, -1);
+        this.f4f_1 = null;
+        this.g4f_1 = -1;
+        this.h4f_1 = -1;
+      }
+    }
+    initMetadataForClass($, 'UnsafeCursor', UnsafeCursor);
+    UnsafeCursorClass = $;
+  }
+  return UnsafeCursorClass;
+}
+var BufferClass;
+function Buffer() {
+  if (BufferClass === VOID) {
+    class $ {
+      constructor() {
+        this.u4c_1 = null;
+        this.v4c_1 = new (Long())(0, 0);
+      }
+      f1o() {
+        return this;
+      }
+      g1o() {
+        return equalsLong(this.v4c_1, new (Long())(0, 0));
+      }
+      h1o(byteCount) {
+        if (compare(this.v4c_1, byteCount) < 0)
+          throw EOFException().l4f(null);
+      }
+      i1o(byteCount) {
+        return compare(this.v4c_1, byteCount) >= 0;
+      }
+      m4f(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.v4c_1, offset_0, byteCount_0);
+          if (equalsLong(byteCount_0, new (Long())(0, 0))) {
+            tmp$ret$0 = this;
+            break $l$block;
+          }
+          out.v4c_1 = add(out.v4c_1, byteCount_0);
+          var s = this.u4c_1;
+          while (compare(offset_0, fromInt(ensureNotNull(s).l4d_1 - s.k4d_1 | 0)) >= 0) {
+            offset_0 = subtract(offset_0, fromInt(s.l4d_1 - s.k4d_1 | 0));
+            s = s.o4d_1;
+          }
+          while (compare(byteCount_0, new (Long())(0, 0)) > 0) {
+            var copy = ensureNotNull(s).s4d();
+            copy.k4d_1 = copy.k4d_1 + convertToInt(offset_0) | 0;
+            var tmp = copy;
+            var tmp0 = copy.k4d_1 + convertToInt(byteCount_0) | 0;
+            // Inline function 'kotlin.comparisons.minOf' call
+            var b = copy.l4d_1;
+            tmp.l4d_1 = Math.min(tmp0, b);
+            if (out.u4c_1 == null) {
+              copy.p4d_1 = copy;
+              copy.o4d_1 = copy.p4d_1;
+              out.u4c_1 = copy.o4d_1;
+            } else {
+              ensureNotNull(ensureNotNull(out.u4c_1).p4d_1).u4d(copy);
+            }
+            byteCount_0 = subtract(byteCount_0, fromInt(copy.l4d_1 - copy.k4d_1 | 0));
+            offset_0 = new (Long())(0, 0);
+            s = s.o4d_1;
+          }
+          tmp$ret$0 = this;
+        }
+        return tmp$ret$0;
+      }
+      b1p(pos) {
+        var tmp$ret$0;
+        $l$block_1: {
+          // Inline function 'okio.internal.commonGet' call
+          checkOffsetAndCount(this.v4c_1, pos, new (Long())(1, 0));
+          // Inline function 'okio.internal.seek' call
+          var tmp0_elvis_lhs = this.u4c_1;
+          var tmp;
+          if (tmp0_elvis_lhs == null) {
+            var offset = new (Long())(-1, -1);
+            tmp$ret$0 = ensureNotNull(null).j4d_1[convertToInt(subtract(add(numberToLong(null.k4d_1), pos), offset))];
+            break $l$block_1;
+          } else {
+            tmp = tmp0_elvis_lhs;
+          }
+          var s = tmp;
+          if (compare(subtract(this.v4c_1, pos), pos) < 0) {
+            var offset_0 = this.v4c_1;
+            while (compare(offset_0, pos) > 0) {
+              s = ensureNotNull(s.p4d_1);
+              offset_0 = subtract(offset_0, fromInt(s.l4d_1 - s.k4d_1 | 0));
+            }
+            var tmp0 = s;
+            var offset_1 = offset_0;
+            tmp$ret$0 = ensureNotNull(tmp0).j4d_1[convertToInt(subtract(add(numberToLong(tmp0.k4d_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.l4d_1 - s.k4d_1 | 0;
+              var nextOffset = add(tmp0_0, fromInt(other));
+              if (compare(nextOffset, pos) > 0)
+                break $l$loop;
+              s = ensureNotNull(s.o4d_1);
+              offset_2 = nextOffset;
+            }
+            var tmp0_1 = s;
+            var offset_3 = offset_2;
+            tmp$ret$0 = ensureNotNull(tmp0_1).j4d_1[convertToInt(subtract(add(numberToLong(tmp0_1.k4d_1), pos), offset_3))];
+            break $l$block_1;
+          }
+        }
+        return tmp$ret$0;
+      }
+      n4f() {
+        var tmp$ret$0;
+        $l$block: {
+          // Inline function 'okio.internal.commonCompleteSegmentByteCount' call
+          var result = this.v4c_1;
+          if (equalsLong(result, new (Long())(0, 0))) {
+            tmp$ret$0 = new (Long())(0, 0);
+            break $l$block;
+          }
+          var tail = ensureNotNull(ensureNotNull(this.u4c_1).p4d_1);
+          if (tail.l4d_1 < 8192 && tail.n4d_1) {
+            result = subtract(result, fromInt(tail.l4d_1 - tail.k4d_1 | 0));
+          }
+          tmp$ret$0 = result;
+        }
+        return tmp$ret$0;
+      }
+      j1o() {
+        // Inline function 'okio.internal.commonReadByte' call
+        if (equalsLong(this.v4c_1, new (Long())(0, 0)))
+          throw EOFException().o4f();
+        var segment = ensureNotNull(this.u4c_1);
+        var pos = segment.k4d_1;
+        var limit = segment.l4d_1;
+        var data = segment.j4d_1;
+        var tmp0 = pos;
+        pos = tmp0 + 1 | 0;
+        var b = data[tmp0];
+        this.v4c_1 = subtract(this.v4c_1, new (Long())(1, 0));
+        if (pos === limit) {
+          this.u4c_1 = segment.t4d();
+          SegmentPool_instance.a4e(segment);
+        } else {
+          segment.k4d_1 = pos;
+        }
+        return b;
+      }
+      g4d() {
+        var tmp$ret$4;
+        $l$block: {
+          // Inline function 'okio.internal.commonReadInt' call
+          if (compare(this.v4c_1, new (Long())(4, 0)) < 0)
+            throw EOFException().o4f();
+          var segment = ensureNotNull(this.u4c_1);
+          var pos = segment.k4d_1;
+          var limit = segment.l4d_1;
+          if (compare(fromInt(limit - pos | 0), new (Long())(4, 0)) < 0) {
+            // Inline function 'okio.and' call
+            var tmp = (this.j1o() & 255) << 24;
+            // Inline function 'okio.and' call
+            var tmp_0 = tmp | (this.j1o() & 255) << 16;
+            // Inline function 'okio.and' call
+            var tmp_1 = tmp_0 | (this.j1o() & 255) << 8;
+            // Inline function 'okio.and' call
+            tmp$ret$4 = tmp_1 | this.j1o() & 255;
+            break $l$block;
+          }
+          var data = segment.j4d_1;
+          var tmp3 = pos;
+          pos = tmp3 + 1 | 0;
+          // Inline function 'okio.and' call
+          var tmp_2 = (data[tmp3] & 255) << 24;
+          var tmp2 = pos;
+          pos = tmp2 + 1 | 0;
+          // Inline function 'okio.and' call
+          var tmp_3 = tmp_2 | (data[tmp2] & 255) << 16;
+          var tmp1 = pos;
+          pos = tmp1 + 1 | 0;
+          // Inline function 'okio.and' call
+          var tmp_4 = tmp_3 | (data[tmp1] & 255) << 8;
+          var tmp0 = pos;
+          pos = tmp0 + 1 | 0;
+          // Inline function 'okio.and' call
+          var i = tmp_4 | data[tmp0] & 255;
+          this.v4c_1 = subtract(this.v4c_1, new (Long())(4, 0));
+          if (pos === limit) {
+            this.u4c_1 = segment.t4d();
+            SegmentPool_instance.a4e(segment);
+          } else {
+            segment.k4d_1 = pos;
+          }
+          tmp$ret$4 = i;
+        }
+        return tmp$ret$4;
+      }
+      p4f() {
+        // Inline function 'okio.internal.commonReadByteString' call
+        return this.q4f(this.v4c_1);
+      }
+      q4f(byteCount) {
+        var tmp$ret$4;
+        $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));
+          }
+          if (compare(this.v4c_1, byteCount) < 0)
+            throw EOFException().o4f();
+          if (compare(byteCount, new (Long())(4096, 0)) >= 0) {
+            // Inline function 'kotlin.also' call
+            var this_0 = this.s4f(convertToInt(byteCount));
+            this.d1p(byteCount);
+            tmp$ret$4 = this_0;
+            break $l$block_0;
+          } else {
+            tmp$ret$4 = new (ByteString())(this.r4f(byteCount));
+            break $l$block_0;
+          }
+        }
+        return tmp$ret$4;
+      }
+      t4f() {
+        return this.g4e(this.v4c_1);
+      }
+      g4e(byteCount) {
+        var tmp$ret$2;
+        $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));
+          }
+          if (compare(this.v4c_1, byteCount) < 0)
+            throw EOFException().o4f();
+          if (equalsLong(byteCount, new (Long())(0, 0))) {
+            tmp$ret$2 = '';
+            break $l$block_0;
+          }
+          var s = ensureNotNull(this.u4c_1);
+          if (compare(add(numberToLong(s.k4d_1), byteCount), fromInt(s.l4d_1)) > 0) {
+            tmp$ret$2 = commonToUtf8String(this.r4f(byteCount));
+            break $l$block_0;
+          }
+          var result = commonToUtf8String(s.j4d_1, s.k4d_1, s.k4d_1 + convertToInt(byteCount) | 0);
+          s.k4d_1 = s.k4d_1 + convertToInt(byteCount) | 0;
+          this.v4c_1 = subtract(this.v4c_1, byteCount);
+          if (s.k4d_1 === s.l4d_1) {
+            this.u4c_1 = s.t4d();
+            SegmentPool_instance.a4e(s);
+          }
+          tmp$ret$2 = result;
+        }
+        return tmp$ret$2;
+      }
+      u4f() {
+        return this.v4f(new (Long())(-1, 2147483647));
+      }
+      v4f(limit) {
+        var tmp$ret$3;
+        $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));
+          }
+          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.w4f(toByte(tmp$ret$2), new (Long())(0, 0), scanLength);
+          if (!equalsLong(newline, new (Long())(-1, -1))) {
+            tmp$ret$3 = readUtf8Line(this, newline);
+            break $l$block_0;
+          }
+          var tmp;
+          var tmp_0;
+          if (compare(scanLength, this.v4c_1) < 0) {
+            // Inline function 'kotlin.Long.minus' call
+            var tmp$ret$4 = subtract(scanLength, fromInt(1));
+            var tmp_1 = this.b1p(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);
+            tmp_0 = tmp_1 === toByte(tmp$ret$5);
+          } else {
+            tmp_0 = false;
+          }
+          if (tmp_0) {
+            var tmp_2 = this.b1p(scanLength);
+            // Inline function 'kotlin.code' call
+            var this_2 = _Char___init__impl__6a9atx(10);
+            var tmp$ret$6 = Char__toInt_impl_vasixd(this_2);
+            tmp = tmp_2 === toByte(tmp$ret$6);
+          } else {
+            tmp = false;
+          }
+          if (tmp) {
+            tmp$ret$3 = 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.v4c_1;
+          // Inline function 'kotlin.comparisons.minOf' call
+          var a = fromInt(32);
+          var tmp$ret$8 = compare(a, b) <= 0 ? a : b;
+          this.m4f(data, tmp_3, tmp$ret$8);
+          // Inline function 'kotlin.comparisons.minOf' call
+          var a_0 = this.v4c_1;
+          var tmp$ret$9 = compare(a_0, limit) <= 0 ? a_0 : limit;
+          throw EOFException().l4f('\\n not found: limit=' + tmp$ret$9.toString() + ' content=' + data.p4f().t4e() + '\u2026');
+        }
+        return tmp$ret$3;
+      }
+      x4f(options) {
+        var tmp$ret$0;
+        $l$block: {
+          // Inline function 'okio.internal.commonSelect' call
+          var index = selectPrefix(this, options);
+          if (index === -1) {
+            tmp$ret$0 = -1;
+            break $l$block;
+          }
+          var selectedSize = options.c4d_1[index].v2();
+          this.d1p(fromInt(selectedSize));
+          tmp$ret$0 = index;
+        }
+        return tmp$ret$0;
+      }
+      y4f() {
+        // Inline function 'okio.internal.commonReadByteArray' call
+        return this.r4f(this.v4c_1);
+      }
+      r4f(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));
+        }
+        if (compare(this.v4c_1, byteCount) < 0)
+          throw EOFException().o4f();
+        var result = new Int8Array(convertToInt(byteCount));
+        this.z4f(result);
+        return result;
+      }
+      z4f(sink) {
+        // Inline function 'okio.internal.commonReadFully' call
+        var offset = 0;
+        while (offset < sink.length) {
+          var read = this.a4g(sink, offset, sink.length - offset | 0);
+          if (read === -1)
+            throw EOFException().o4f();
+          offset = offset + read | 0;
+        }
+        return Unit_instance;
+      }
+      a4g(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.u4c_1;
+          var tmp;
+          if (tmp0_elvis_lhs == null) {
+            tmp$ret$0 = -1;
+            break $l$block;
+          } else {
+            tmp = tmp0_elvis_lhs;
+          }
+          var s = tmp;
+          // Inline function 'kotlin.comparisons.minOf' call
+          var b = s.l4d_1 - s.k4d_1 | 0;
+          var toCopy = Math.min(byteCount, b);
+          var tmp0 = s.j4d_1;
+          var tmp6 = s.k4d_1;
+          // Inline function 'kotlin.collections.copyInto' call
+          var endIndex = s.k4d_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.k4d_1 = s.k4d_1 + toCopy | 0;
+          this.v4c_1 = subtract(this.v4c_1, fromInt(toCopy));
+          if (s.k4d_1 === s.l4d_1) {
+            this.u4c_1 = s.t4d();
+            SegmentPool_instance.a4e(s);
+          }
+          tmp$ret$0 = toCopy;
+        }
+        return tmp$ret$0;
+      }
+      r4() {
+        // Inline function 'okio.internal.commonClear' call
+        this.d1p(this.v4c_1);
+        return Unit_instance;
+      }
+      d1p(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.u4c_1;
+          var tmp;
+          if (tmp0_elvis_lhs == null) {
+            throw EOFException().o4f();
+          } else {
+            tmp = tmp0_elvis_lhs;
+          }
+          var head = tmp;
+          var tmp0 = byteCount_0;
+          // Inline function 'okio.minOf' call
+          var b = head.l4d_1 - head.k4d_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.v4c_1 = subtract(this.v4c_1, fromInt(toSkip));
+          byteCount_0 = subtract(byteCount_0, fromInt(toSkip));
+          head.k4d_1 = head.k4d_1 + toSkip | 0;
+          if (head.k4d_1 === head.l4d_1) {
+            this.u4c_1 = head.t4d();
+            SegmentPool_instance.a4e(head);
+          }
+        }
+        return Unit_instance;
+      }
+      b4g(byteString) {
+        // Inline function 'okio.internal.commonWrite' call
+        var byteCount = byteString.v2();
+        byteString.x4e(this, 0, byteCount);
+        return this;
+      }
+      c4g(minimumCapacity) {
+        var tmp$ret$2;
+        $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));
+          }
+          if (this.u4c_1 == null) {
+            var result = SegmentPool_instance.o1p();
+            this.u4c_1 = result;
+            result.p4d_1 = result;
+            result.o4d_1 = result;
+            tmp$ret$2 = result;
+            break $l$block;
+          }
+          var tail = ensureNotNull(this.u4c_1).p4d_1;
+          if ((ensureNotNull(tail).l4d_1 + minimumCapacity | 0) > 8192 || !tail.n4d_1) {
+            tail = tail.u4d(SegmentPool_instance.o1p());
+          }
+          tmp$ret$2 = tail;
+        }
+        return tmp$ret$2;
+      }
+      d4g(string) {
+        return this.e4g(string, 0, string.length);
+      }
+      e4g(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));
+        }
+        // Inline function 'kotlin.require' call
+        if (!(endIndex >= beginIndex)) {
+          var message_0 = 'endIndex < beginIndex: ' + endIndex + ' < ' + beginIndex;
+          throw IllegalArgumentException().r2(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));
+        }
+        var i = beginIndex;
+        while (i < endIndex) {
+          // Inline function 'kotlin.code' call
+          var this_0 = charCodeAt(string, i);
+          var c = Char__toInt_impl_vasixd(this_0);
+          if (c < 128) {
+            var tail = this.c4g(1);
+            var data = tail.j4d_1;
+            var segmentOffset = tail.l4d_1 - i | 0;
+            // Inline function 'kotlin.comparisons.minOf' call
+            var b = 8192 - segmentOffset | 0;
+            var runLimit = Math.min(endIndex, b);
+            var tmp0 = i;
+            i = tmp0 + 1 | 0;
+            data[segmentOffset + tmp0 | 0] = toByte(c);
+            $l$loop: while (i < runLimit) {
+              // Inline function 'kotlin.code' call
+              var this_1 = charCodeAt(string, i);
+              c = Char__toInt_impl_vasixd(this_1);
+              if (c >= 128)
+                break $l$loop;
+              var tmp1 = i;
+              i = tmp1 + 1 | 0;
+              data[segmentOffset + tmp1 | 0] = toByte(c);
+            }
+            var runSize = (i + segmentOffset | 0) - tail.l4d_1 | 0;
+            tail.l4d_1 = tail.l4d_1 + runSize | 0;
+            this.v4c_1 = add(this.v4c_1, fromInt(runSize));
+          } else if (c < 2048) {
+            var tail_0 = this.c4g(2);
+            tail_0.j4d_1[tail_0.l4d_1] = toByte(c >> 6 | 192);
+            tail_0.j4d_1[tail_0.l4d_1 + 1 | 0] = toByte(c & 63 | 128);
+            tail_0.l4d_1 = tail_0.l4d_1 + 2 | 0;
+            this.v4c_1 = add(this.v4c_1, new (Long())(2, 0));
+            i = i + 1 | 0;
+          } else if (c < 55296 || c > 57343) {
+            var tail_1 = this.c4g(3);
+            tail_1.j4d_1[tail_1.l4d_1] = toByte(c >> 12 | 224);
+            tail_1.j4d_1[tail_1.l4d_1 + 1 | 0] = toByte(c >> 6 & 63 | 128);
+            tail_1.j4d_1[tail_1.l4d_1 + 2 | 0] = toByte(c & 63 | 128);
+            tail_1.l4d_1 = tail_1.l4d_1 + 3 | 0;
+            this.v4c_1 = add(this.v4c_1, new (Long())(3, 0));
+            i = i + 1 | 0;
+          } else {
+            var tmp;
+            if ((i + 1 | 0) < endIndex) {
+              // Inline function 'kotlin.code' call
+              var this_2 = charCodeAt(string, i + 1 | 0);
+              tmp = Char__toInt_impl_vasixd(this_2);
+            } else {
+              tmp = 0;
+            }
+            var low = tmp;
+            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.f4g(tmp$ret$10);
+              i = i + 1 | 0;
+            } else {
+              var codePoint = 65536 + ((c & 1023) << 10 | low & 1023) | 0;
+              var tail_2 = this.c4g(4);
+              tail_2.j4d_1[tail_2.l4d_1] = toByte(codePoint >> 18 | 240);
+              tail_2.j4d_1[tail_2.l4d_1 + 1 | 0] = toByte(codePoint >> 12 & 63 | 128);
+              tail_2.j4d_1[tail_2.l4d_1 + 2 | 0] = toByte(codePoint >> 6 & 63 | 128);
+              tail_2.j4d_1[tail_2.l4d_1 + 3 | 0] = toByte(codePoint & 63 | 128);
+              tail_2.l4d_1 = tail_2.l4d_1 + 4 | 0;
+              this.v4c_1 = add(this.v4c_1, new (Long())(4, 0));
+              i = i + 2 | 0;
+            }
+          }
+        }
+        return this;
+      }
+      g4g(source) {
+        // Inline function 'okio.internal.commonWrite' call
+        return this.h4e(source, 0, source.length);
+      }
+      h4e(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.c4g(1);
+          var tmp0 = limit - offset_0 | 0;
+          // Inline function 'kotlin.comparisons.minOf' call
+          var b = 8192 - tail.l4d_1 | 0;
+          var toCopy = Math.min(tmp0, b);
+          var tmp2 = tail.j4d_1;
+          var tmp4 = tail.l4d_1;
+          var tmp6 = offset_0;
+          // Inline function 'kotlin.collections.copyInto' call
+          var endIndex = offset_0 + toCopy | 0;
+          // Inline function 'kotlin.js.unsafeCast' call
+          // Inline function 'kotlin.js.asDynamic' call
+          var tmp = source;
+          // Inline function 'kotlin.js.unsafeCast' call
+          // Inline function 'kotlin.js.asDynamic' call
+          arrayCopy(tmp, tmp2, tmp4, tmp6, endIndex);
+          offset_0 = offset_0 + toCopy | 0;
+          tail.l4d_1 = tail.l4d_1 + toCopy | 0;
+        }
+        this.v4c_1 = add(this.v4c_1, fromInt(byteCount));
+        return this;
+      }
+      a4d(source) {
+        // Inline function 'okio.internal.commonWriteAll' call
+        var totalBytesRead = new (Long())(0, 0);
+        $l$loop: while (true) {
+          var readCount = source.h4g(this, new (Long())(8192, 0));
+          if (equalsLong(readCount, new (Long())(-1, -1)))
+            break $l$loop;
+          totalBytesRead = add(totalBytesRead, readCount);
+        }
+        return totalBytesRead;
+      }
+      f4g(b) {
+        // Inline function 'okio.internal.commonWriteByte' call
+        var tail = this.c4g(1);
+        var tmp1 = tail.l4d_1;
+        tail.l4d_1 = tmp1 + 1 | 0;
+        tail.j4d_1[tmp1] = toByte(b);
+        this.v4c_1 = add(this.v4c_1, new (Long())(1, 0));
+        return this;
+      }
+      z4c(i) {
+        // Inline function 'okio.internal.commonWriteInt' call
+        var tail = this.c4g(4);
+        var data = tail.j4d_1;
+        var limit = tail.l4d_1;
+        var tmp0 = limit;
+        limit = tmp0 + 1 | 0;
+        data[tmp0] = toByte((i >>> 24 | 0) & 255);
+        var tmp1 = limit;
+        limit = tmp1 + 1 | 0;
+        data[tmp1] = toByte((i >>> 16 | 0) & 255);
+        var tmp2 = limit;
+        limit = tmp2 + 1 | 0;
+        data[tmp2] = toByte((i >>> 8 | 0) & 255);
+        var tmp3 = limit;
+        limit = tmp3 + 1 | 0;
+        data[tmp3] = toByte(i & 255);
+        tail.l4d_1 = limit;
+        this.v4c_1 = add(this.v4c_1, new (Long())(4, 0));
+        return this;
+      }
+      t4c(source, byteCount) {
+        var tmp$ret$4;
+        $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));
+          }
+          checkOffsetAndCount(source.v4c_1, new (Long())(0, 0), byteCount_0);
+          while (compare(byteCount_0, new (Long())(0, 0)) > 0) {
+            if (compare(byteCount_0, fromInt(ensureNotNull(source.u4c_1).l4d_1 - ensureNotNull(source.u4c_1).k4d_1 | 0)) < 0) {
+              var tail = !(this.u4c_1 == null) ? ensureNotNull(this.u4c_1).p4d_1 : null;
+              var tmp;
+              if (!(tail == null) && tail.n4d_1) {
+                var tmp0 = byteCount_0;
+                // Inline function 'kotlin.Long.plus' call
+                var other = tail.l4d_1;
+                var tmp0_0 = add(tmp0, fromInt(other));
+                // Inline function 'kotlin.Long.minus' call
+                var other_0 = tail.m4d_1 ? 0 : tail.k4d_1;
+                var tmp$ret$3 = subtract(tmp0_0, fromInt(other_0));
+                tmp = compare(tmp$ret$3, new (Long())(8192, 0)) <= 0;
+              } else {
+                tmp = false;
+              }
+              if (tmp) {
+                ensureNotNull(source.u4c_1).z4d(tail, convertToInt(byteCount_0));
+                source.v4c_1 = subtract(source.v4c_1, byteCount_0);
+                this.v4c_1 = add(this.v4c_1, byteCount_0);
+                tmp$ret$4 = Unit_instance;
+                break $l$block;
+              } else {
+                source.u4c_1 = ensureNotNull(source.u4c_1).v4d(convertToInt(byteCount_0));
+              }
+            }
+            var segmentToMove = source.u4c_1;
+            var movedByteCount = fromInt(ensureNotNull(segmentToMove).l4d_1 - segmentToMove.k4d_1 | 0);
+            source.u4c_1 = segmentToMove.t4d();
+            if (this.u4c_1 == null) {
+              this.u4c_1 = segmentToMove;
+              segmentToMove.p4d_1 = segmentToMove;
+              segmentToMove.o4d_1 = segmentToMove.p4d_1;
+            } else {
+              var tail_0 = ensureNotNull(this.u4c_1).p4d_1;
+              tail_0 = ensureNotNull(tail_0).u4d(segmentToMove);
+              tail_0.y4d();
+            }
+            source.v4c_1 = subtract(source.v4c_1, movedByteCount);
+            this.v4c_1 = add(this.v4c_1, movedByteCount);
+            byteCount_0 = subtract(byteCount_0, movedByteCount);
+          }
+          tmp$ret$4 = Unit_instance;
+        }
+        return tmp$ret$4;
+      }
+      h4g(sink, byteCount) {
+        var tmp$ret$2;
+        $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));
+          }
+          if (equalsLong(this.v4c_1, new (Long())(0, 0))) {
+            tmp$ret$2 = new (Long())(-1, -1);
+            break $l$block;
+          }
+          if (compare(byteCount_0, this.v4c_1) > 0)
+            byteCount_0 = this.v4c_1;
+          sink.t4c(this, byteCount_0);
+          tmp$ret$2 = byteCount_0;
+        }
+        return tmp$ret$2;
+      }
+      w4f(b, fromIndex, toIndex) {
+        var tmp$ret$2;
+        $l$block_8: {
+          // 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.v4c_1.toString() + ' fromIndex=' + fromIndex_0.toString() + ' toIndex=' + toIndex_0.toString();
+            throw IllegalArgumentException().r2(toString(message));
+          }
+          if (compare(toIndex_0, this.v4c_1) > 0)
+            toIndex_0 = this.v4c_1;
+          if (equalsLong(fromIndex_0, toIndex_0)) {
+            tmp$ret$2 = new (Long())(-1, -1);
+            break $l$block_8;
+          }
+          // Inline function 'okio.internal.seek' call
+          var fromIndex_1 = fromIndex_0;
+          var tmp0_elvis_lhs = this.u4c_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.j4d_1;
+              var tmp0 = fromInt(s.l4d_1);
+              // Inline function 'kotlin.comparisons.minOf' call
+              var b_0 = subtract(add(numberToLong(s.k4d_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.k4d_1), fromIndex_0), offset_0));
+              while (pos < limit) {
+                if (data[pos] === b) {
+                  tmp$ret$2 = add(numberToLong(pos - s.k4d_1 | 0), offset_0);
+                  break $l$block_8;
+                }
+                pos = pos + 1 | 0;
+              }
+              offset_0 = add(offset_0, fromInt(s.l4d_1 - s.k4d_1 | 0));
+              fromIndex_0 = offset_0;
+              s = ensureNotNull(s.o4d_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.v4c_1, fromIndex_1), fromIndex_1) < 0) {
+            var offset_1 = this.v4c_1;
+            while (compare(offset_1, fromIndex_1) > 0) {
+              s_0 = ensureNotNull(s_0.p4d_1);
+              offset_1 = subtract(offset_1, fromInt(s_0.l4d_1 - s_0.k4d_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;
+            } 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.j4d_1;
+              var tmp0_1 = fromInt(s_1.l4d_1);
+              // Inline function 'kotlin.comparisons.minOf' call
+              var b_1 = subtract(add(numberToLong(s_1.k4d_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.k4d_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.k4d_1 | 0), offset_3);
+                  break $l$block_8;
+                }
+                pos_0 = pos_0 + 1 | 0;
+              }
+              offset_3 = add(offset_3, fromInt(s_1.l4d_1 - s_1.k4d_1 | 0));
+              fromIndex_0 = offset_3;
+              s_1 = ensureNotNull(s_1.o4d_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.l4d_1 - s_0.k4d_1 | 0;
+              var nextOffset = add(tmp0_2, fromInt(other));
+              if (compare(nextOffset, fromIndex_1) > 0)
+                break $l$loop;
+              s_0 = ensureNotNull(s_0.o4d_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;
+            } 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.j4d_1;
+              var tmp0_4 = fromInt(s_2.l4d_1);
+              // Inline function 'kotlin.comparisons.minOf' call
+              var b_2 = subtract(add(numberToLong(s_2.k4d_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.k4d_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.k4d_1 | 0), offset_6);
+                  break $l$block_8;
+                }
+                pos_1 = pos_1 + 1 | 0;
+              }
+              offset_6 = add(offset_6, fromInt(s_2.l4d_1 - s_2.k4d_1 | 0));
+              fromIndex_0 = offset_6;
+              s_2 = ensureNotNull(s_2.o4d_1);
+            }
+            tmp$ret$2 = new (Long())(-1, -1);
+            break $l$block_8;
+          }
+        }
+        return tmp$ret$2;
+      }
+      i4g(bytes) {
+        return this.j4g(bytes, new (Long())(0, 0));
+      }
+      j4g(bytes, fromIndex) {
+        var tmp$ret$4;
+        $l$block_7: {
+          // Inline function 'okio.internal.commonIndexOf' call
+          var fromIndex_0 = fromIndex;
+          // Inline function 'kotlin.require' call
+          if (!(bytes.v2() > 0)) {
+            var message = 'bytes is empty';
+            throw IllegalArgumentException().r2(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));
+          }
+          // Inline function 'okio.internal.seek' call
+          var fromIndex_1 = fromIndex_0;
+          var tmp0_elvis_lhs = this.u4c_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.s4e();
+            var b0 = targetByteArray[0];
+            var bytesSize = bytes.v2();
+            // Inline function 'kotlin.Long.minus' call
+            var this_0 = this.v4c_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.j4d_1;
+              var tmp0 = s.l4d_1;
+              // Inline function 'okio.minOf' call
+              var b = subtract(add(numberToLong(s.k4d_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.k4d_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.k4d_1 | 0), offset_0);
+                    break $l$block_7;
+                  }
+                }
+                 while (inductionVariable < segmentLimit);
+              offset_0 = add(offset_0, fromInt(s.l4d_1 - s.k4d_1 | 0));
+              fromIndex_0 = offset_0;
+              s = ensureNotNull(s.o4d_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.v4c_1, fromIndex_1), fromIndex_1) < 0) {
+            var offset_1 = this.v4c_1;
+            while (compare(offset_1, fromIndex_1) > 0) {
+              s_0 = ensureNotNull(s_0.p4d_1);
+              offset_1 = subtract(offset_1, fromInt(s_0.l4d_1 - s_0.k4d_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;
+            } else {
+              tmp_1 = tmp0_0;
+            }
+            var s_1 = tmp_1;
+            var offset_3 = offset_2;
+            var targetByteArray_0 = bytes.s4e();
+            var b0_0 = targetByteArray_0[0];
+            var bytesSize_0 = bytes.v2();
+            // Inline function 'kotlin.Long.minus' call
+            var this_1 = this.v4c_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.j4d_1;
+              var tmp0_1 = s_1.l4d_1;
+              // Inline function 'okio.minOf' call
+              var b_0 = subtract(add(numberToLong(s_1.k4d_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.k4d_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.k4d_1 | 0), offset_3);
+                    break $l$block_7;
+                  }
+                }
+                 while (inductionVariable_0 < segmentLimit_0);
+              offset_3 = add(offset_3, fromInt(s_1.l4d_1 - s_1.k4d_1 | 0));
+              fromIndex_0 = offset_3;
+              s_1 = ensureNotNull(s_1.o4d_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.l4d_1 - s_0.k4d_1 | 0;
+              var nextOffset = add(tmp0_2, fromInt(other));
+              if (compare(nextOffset, fromIndex_1) > 0)
+                break $l$loop;
+              s_0 = ensureNotNull(s_0.o4d_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;
+            } else {
+              tmp_2 = tmp0_3;
+            }
+            var s_2 = tmp_2;
+            var offset_6 = offset_5;
+            var targetByteArray_1 = bytes.s4e();
+            var b0_1 = targetByteArray_1[0];
+            var bytesSize_1 = bytes.v2();
+            // Inline function 'kotlin.Long.minus' call
+            var this_2 = this.v4c_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.j4d_1;
+              var tmp0_4 = s_2.l4d_1;
+              // Inline function 'okio.minOf' call
+              var b_1 = subtract(add(numberToLong(s_2.k4d_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.k4d_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.k4d_1 | 0), offset_6);
+                    break $l$block_7;
+                  }
+                }
+                 while (inductionVariable_1 < segmentLimit_1);
+              offset_6 = add(offset_6, fromInt(s_2.l4d_1 - s_2.k4d_1 | 0));
+              fromIndex_0 = offset_6;
+              s_2 = ensureNotNull(s_2.o4d_1);
+            }
+            tmp$ret$4 = new (Long())(-1, -1);
+            break $l$block_7;
+          }
+        }
+        return tmp$ret$4;
+      }
+      k4g(targetBytes) {
+        return this.l4g(targetBytes, new (Long())(0, 0));
+      }
+      l4g(targetBytes, fromIndex) {
+        var tmp$ret$2;
+        $l$block_10: {
+          // 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));
+          }
+          // Inline function 'okio.internal.seek' call
+          var fromIndex_1 = fromIndex_0;
+          var tmp0_elvis_lhs = this.u4c_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.v4c_1) < 0) {
+                var data = s.j4d_1;
+                var pos = convertToInt(subtract(add(numberToLong(s.k4d_1), fromIndex_0), offset_0));
+                var limit = s.l4d_1;
+                while (pos < limit) {
+                  var b = data[pos];
+                  if (b === b0 || b === b1) {
+                    tmp$ret$2 = add(numberToLong(pos - s.k4d_1 | 0), offset_0);
+                    break $l$block_10;
+                  }
+                  pos = pos + 1 | 0;
+                }
+                offset_0 = add(offset_0, fromInt(s.l4d_1 - s.k4d_1 | 0));
+                fromIndex_0 = offset_0;
+                s = ensureNotNull(s.o4d_1);
+              }
+            } else {
+              var targetByteArray = targetBytes.s4e();
+              while (compare(offset_0, this.v4c_1) < 0) {
+                var data_0 = s.j4d_1;
+                var pos_0 = convertToInt(subtract(add(numberToLong(s.k4d_1), fromIndex_0), offset_0));
+                var limit_0 = s.l4d_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.k4d_1 | 0), offset_0);
+                      break $l$block_10;
+                    }
+                  }
+                  pos_0 = pos_0 + 1 | 0;
+                }
+                offset_0 = add(offset_0, fromInt(s.l4d_1 - s.k4d_1 | 0));
+                fromIndex_0 = offset_0;
+                s = ensureNotNull(s.o4d_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.v4c_1, fromIndex_1), fromIndex_1) < 0) {
+            var offset_1 = this.v4c_1;
+            while (compare(offset_1, fromIndex_1) > 0) {
+              s_0 = ensureNotNull(s_0.p4d_1);
+              offset_1 = subtract(offset_1, fromInt(s_0.l4d_1 - s_0.k4d_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;
+            } else {
+              tmp_1 = tmp0;
+            }
+            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.v4c_1) < 0) {
+                var data_1 = s_1.j4d_1;
+                var pos_1 = convertToInt(subtract(add(numberToLong(s_1.k4d_1), fromIndex_0), offset_3));
+                var limit_1 = s_1.l4d_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.k4d_1 | 0), offset_3);
+                    break $l$block_10;
+                  }
+                  pos_1 = pos_1 + 1 | 0;
+                }
+                offset_3 = add(offset_3, fromInt(s_1.l4d_1 - s_1.k4d_1 | 0));
+                fromIndex_0 = offset_3;
+                s_1 = ensureNotNull(s_1.o4d_1);
+              }
+            } else {
+              var targetByteArray_0 = targetBytes.s4e();
+              while (compare(offset_3, this.v4c_1) < 0) {
+                var data_2 = s_1.j4d_1;
+                var pos_2 = convertToInt(subtract(add(numberToLong(s_1.k4d_1), fromIndex_0), offset_3));
+                var limit_2 = s_1.l4d_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.k4d_1 | 0), offset_3);
+                      break $l$block_10;
+                    }
+                  }
+                  pos_2 = pos_2 + 1 | 0;
+                }
+                offset_3 = add(offset_3, fromInt(s_1.l4d_1 - s_1.k4d_1 | 0));
+                fromIndex_0 = offset_3;
+                s_1 = ensureNotNull(s_1.o4d_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.l4d_1 - s_0.k4d_1 | 0;
+              var nextOffset = add(tmp0_0, fromInt(other));
+              if (compare(nextOffset, fromIndex_1) > 0)
+                break $l$loop;
+              s_0 = ensureNotNull(s_0.o4d_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;
+            } 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.v4c_1) < 0) {
+                var data_3 = s_2.j4d_1;
+                var pos_3 = convertToInt(subtract(add(numberToLong(s_2.k4d_1), fromIndex_0), offset_6));
+                var limit_3 = s_2.l4d_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.k4d_1 | 0), offset_6);
+                    break $l$block_10;
+                  }
+                  pos_3 = pos_3 + 1 | 0;
+                }
+                offset_6 = add(offset_6, fromInt(s_2.l4d_1 - s_2.k4d_1 | 0));
+                fromIndex_0 = offset_6;
+                s_2 = ensureNotNull(s_2.o4d_1);
+              }
+            } else {
+              var targetByteArray_1 = targetBytes.s4e();
+              while (compare(offset_6, this.v4c_1) < 0) {
+                var data_4 = s_2.j4d_1;
+                var pos_4 = convertToInt(subtract(add(numberToLong(s_2.k4d_1), fromIndex_0), offset_6));
+                var limit_4 = s_2.l4d_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.k4d_1 | 0), offset_6);
+                      break $l$block_10;
+                    }
+                  }
+                  pos_4 = pos_4 + 1 | 0;
+                }
+                offset_6 = add(offset_6, fromInt(s_2.l4d_1 - s_2.k4d_1 | 0));
+                fromIndex_0 = offset_6;
+                s_2 = ensureNotNull(s_2.o4d_1);
+              }
+            }
+            tmp$ret$2 = new (Long())(-1, -1);
+            break $l$block_10;
+          }
+        }
+        return tmp$ret$2;
+      }
+      m4g(offset, bytes) {
+        return this.n4g(offset, bytes, 0, bytes.v2());
+      }
+      n4g(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.v4c_1, offset), fromInt(byteCount)) < 0 || (bytes.v2() - bytesOffset | 0) < byteCount) {
+            tmp$ret$0 = false;
+            break $l$block_0;
+          }
+          var inductionVariable = 0;
+          if (inductionVariable < byteCount)
+            do {
+              var i = inductionVariable;
+              inductionVariable = inductionVariable + 1 | 0;
+              // Inline function 'kotlin.Long.plus' call
+              var tmp$ret$1 = add(offset, fromInt(i));
+              if (!(this.b1p(tmp$ret$1) === bytes.u2(bytesOffset + i | 0))) {
+                tmp$ret$0 = false;
+                break $l$block_0;
+              }
+            }
+             while (inductionVariable < byteCount);
+          tmp$ret$0 = true;
+        }
+        return tmp$ret$0;
+      }
+      ad() {
+        return Unit_instance;
+      }
+      o6() {
+        return Unit_instance;
+      }
+      equals(other) {
+        var tmp$ret$0;
+        $l$block_3: {
+          // Inline function 'okio.internal.commonEquals' call
+          if (this === other) {
+            tmp$ret$0 = true;
+            break $l$block_3;
+          }
+          if (!(other instanceof Buffer())) {
+            tmp$ret$0 = false;
+            break $l$block_3;
+          }
+          if (!equalsLong(this.v4c_1, other.v4c_1)) {
+            tmp$ret$0 = false;
+            break $l$block_3;
+          }
+          if (equalsLong(this.v4c_1, new (Long())(0, 0))) {
+            tmp$ret$0 = true;
+            break $l$block_3;
+          }
+          var sa = ensureNotNull(this.u4c_1);
+          var sb = ensureNotNull(other.u4c_1);
+          var posA = sa.k4d_1;
+          var posB = sb.k4d_1;
+          var pos = new (Long())(0, 0);
+          var count;
+          while (compare(pos, this.v4c_1) < 0) {
+            var tmp0 = sa.l4d_1 - posA | 0;
+            // Inline function 'kotlin.comparisons.minOf' call
+            var b = sb.l4d_1 - posB | 0;
+            var tmp$ret$1 = Math.min(tmp0, b);
+            count = fromInt(tmp$ret$1);
+            var inductionVariable = new (Long())(0, 0);
+            if (compare(inductionVariable, count) < 0)
+              do {
+                var i = inductionVariable;
+                inductionVariable = add(inductionVariable, new (Long())(1, 0));
+                var tmp = sa.j4d_1;
+                var tmp1 = posA;
+                posA = tmp1 + 1 | 0;
+                var tmp_0 = tmp[tmp1];
+                var tmp_1 = sb.j4d_1;
+                var tmp2 = posB;
+                posB = tmp2 + 1 | 0;
+                if (!(tmp_0 === tmp_1[tmp2])) {
+                  tmp$ret$0 = false;
+                  break $l$block_3;
+                }
+              }
+               while (compare(inductionVariable, count) < 0);
+            if (posA === sa.l4d_1) {
+              sa = ensureNotNull(sa.o4d_1);
+              posA = sa.k4d_1;
+            }
+            if (posB === sb.l4d_1) {
+              sb = ensureNotNull(sb.o4d_1);
+              posB = sb.k4d_1;
+            }
+            pos = add(pos, count);
+          }
+          tmp$ret$0 = true;
+        }
+        return tmp$ret$0;
+      }
+      hashCode() {
+        var tmp$ret$0;
+        $l$block: {
+          // Inline function 'okio.internal.commonHashCode' call
+          var tmp0_elvis_lhs = this.u4c_1;
+          var tmp;
+          if (tmp0_elvis_lhs == null) {
+            tmp$ret$0 = 0;
+            break $l$block;
+          } else {
+            tmp = tmp0_elvis_lhs;
+          }
+          var s = tmp;
+          var result = 1;
+          do {
+            var pos = s.k4d_1;
+            var limit = s.l4d_1;
+            while (pos < limit) {
+              result = imul(31, result) + s.j4d_1[pos] | 0;
+              pos = pos + 1 | 0;
+            }
+            s = ensureNotNull(s.o4d_1);
+          }
+           while (!(s === this.u4c_1));
+          tmp$ret$0 = result;
+        }
+        return tmp$ret$0;
+      }
+      toString() {
+        return this.o4g().toString();
+      }
+      o4g() {
+        // Inline function 'okio.internal.commonSnapshot' call
+        // Inline function 'kotlin.check' call
+        if (!(compare(this.v4c_1, new (Long())(2147483647, 0)) <= 0)) {
+          var message = 'size > Int.MAX_VALUE: ' + this.v4c_1.toString();
+          throw IllegalStateException().o(toString(message));
+        }
+        return this.s4f(convertToInt(this.v4c_1));
+      }
+      s4f(byteCount) {
+        var tmp$ret$0;
+        $l$block: {
+          // Inline function 'okio.internal.commonSnapshot' call
+          if (byteCount === 0) {
+            tmp$ret$0 = Companion_getInstance().n4e_1;
+            break $l$block;
+          }
+          checkOffsetAndCount(this.v4c_1, new (Long())(0, 0), fromInt(byteCount));
+          var offset = 0;
+          var segmentCount = 0;
+          var s = this.u4c_1;
+          while (offset < byteCount) {
+            if (ensureNotNull(s).l4d_1 === s.k4d_1) {
+              throw AssertionError().if('s.limit == s.pos');
+            }
+            offset = offset + (s.l4d_1 - s.k4d_1 | 0) | 0;
+            segmentCount = segmentCount + 1 | 0;
+            s = s.o4d_1;
+          }
+          // Inline function 'kotlin.arrayOfNulls' call
+          var size = segmentCount;
+          var segments = Array(size);
+          var directory = new Int32Array(imul(segmentCount, 2));
+          offset = 0;
+          segmentCount = 0;
+          s = this.u4c_1;
+          while (offset < byteCount) {
+            segments[segmentCount] = ensureNotNull(s).j4d_1;
+            offset = offset + (s.l4d_1 - s.k4d_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.k4d_1;
+            s.m4d_1 = true;
+            segmentCount = segmentCount + 1 | 0;
+            s = s.o4d_1;
+          }
+          tmp$ret$0 = new (SegmentedByteString())(isArray(segments) ? segments : THROW_CCE(), directory);
+        }
+        return tmp$ret$0;
+      }
+    }
+    initMetadataForClass($, 'Buffer', Buffer);
+    BufferClass = $;
+  }
+  return BufferClass;
+}
+//region block: exports
+export {
+  UnsafeCursor as UnsafeCursor3vg8iqxvd6n5k,
+  Buffer as Buffer3384y49aj0pxr,
+};
+//endregion
+
+//# sourceMappingURL=Buffer.mjs.map