@continuous-excellence/coupling-cli 1.1.685 → 1.1.686

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

@@ -24,44 +24,44 @@ var imul = Math.imul;
 //region block: pre-declaration
 //endregion
 function toByteString($this) {
-  return new (ByteString())($this.z4f());
+  return new (ByteString())($this.s4f());
 }
 var SegmentedByteStringClass;
 function SegmentedByteString() {
   if (SegmentedByteStringClass === VOID) {
     class $ extends ByteString() {
       constructor(segments, directory) {
-        super(Companion_getInstance().r4f_1.f4d_1);
-        this.a4f_1 = segments;
-        this.b4f_1 = directory;
+        super(Companion_getInstance().k4f_1.y4c_1);
+        this.t4e_1 = segments;
+        this.u4e_1 = directory;
       }
-      w4f() {
-        return toByteString(this).w4f();
+      p4f() {
+        return toByteString(this).p4f();
       }
-      x4f(pos) {
+      q4f(pos) {
         // Inline function 'okio.internal.commonInternalGet' call
-        checkOffsetAndCount(fromInt(this.b4f_1[this.a4f_1.length - 1 | 0]), fromInt(pos), new (Long())(1, 0));
+        checkOffsetAndCount(fromInt(this.u4e_1[this.t4e_1.length - 1 | 0]), fromInt(pos), new (Long())(1, 0));
         var segment_0 = segment(this, pos);
-        var segmentOffset = segment_0 === 0 ? 0 : this.b4f_1[segment_0 - 1 | 0];
-        var segmentPos = this.b4f_1[segment_0 + this.a4f_1.length | 0];
-        return this.a4f_1[segment_0][(pos - segmentOffset | 0) + segmentPos | 0];
+        var segmentOffset = segment_0 === 0 ? 0 : this.u4e_1[segment_0 - 1 | 0];
+        var segmentPos = this.u4e_1[segment_0 + this.t4e_1.length | 0];
+        return this.t4e_1[segment_0][(pos - segmentOffset | 0) + segmentPos | 0];
       }
-      y4f() {
+      r4f() {
         // Inline function 'okio.internal.commonGetSize' call
-        return this.b4f_1[this.a4f_1.length - 1 | 0];
+        return this.u4e_1[this.t4e_1.length - 1 | 0];
       }
-      z4f() {
+      s4f() {
         // Inline function 'okio.internal.commonToByteArray' call
         var result = new Int8Array(this.q2());
         var resultPos = 0;
         // Inline function 'okio.internal.forEachSegment' call
-        var segmentCount = this.a4f_1.length;
+        var segmentCount = this.t4e_1.length;
         var s = 0;
         var pos = 0;
         while (s < segmentCount) {
-          var segmentPos = this.b4f_1[segmentCount + s | 0];
-          var nextSegmentOffset = this.b4f_1[s];
-          var tmp0 = this.a4f_1[s];
+          var segmentPos = this.u4e_1[segmentCount + s | 0];
+          var nextSegmentOffset = this.u4e_1[s];
+          var tmp0 = this.t4e_1[s];
           var byteCount = nextSegmentOffset - pos | 0;
           var tmp4 = resultPos;
           // Inline function 'kotlin.collections.copyInto' call
@@ -78,38 +78,38 @@ function SegmentedByteString() {
         }
         return result;
       }
-      a4g(buffer, offset, byteCount) {
+      t4f(buffer, offset, byteCount) {
         // Inline function 'okio.internal.commonWrite' call
         var endIndex = offset + byteCount | 0;
         var s = segment(this, offset);
         var pos = offset;
         while (pos < endIndex) {
-          var segmentOffset = s === 0 ? 0 : this.b4f_1[s - 1 | 0];
-          var segmentSize = this.b4f_1[s] - segmentOffset | 0;
-          var segmentPos = this.b4f_1[this.a4f_1.length + s | 0];
+          var segmentOffset = s === 0 ? 0 : this.u4e_1[s - 1 | 0];
+          var segmentSize = this.u4e_1[s] - segmentOffset | 0;
+          var segmentPos = this.u4e_1[this.t4e_1.length + s | 0];
           // Inline function 'kotlin.comparisons.minOf' call
           var b = segmentOffset + segmentSize | 0;
           var byteCount_0 = Math.min(endIndex, b) - pos | 0;
           var offset_0 = segmentPos + (pos - segmentOffset | 0) | 0;
-          var data = this.a4f_1[s];
-          var segment_0 = Segment().a4e(data, offset_0, offset_0 + byteCount_0 | 0, true, false);
-          if (buffer.d4d_1 == null) {
-            segment_0.y4d_1 = segment_0;
-            segment_0.x4d_1 = segment_0.y4d_1;
-            buffer.d4d_1 = segment_0.x4d_1;
+          var data = this.t4e_1[s];
+          var segment_0 = Segment().t4d(data, offset_0, offset_0 + byteCount_0 | 0, true, false);
+          if (buffer.w4c_1 == null) {
+            segment_0.r4d_1 = segment_0;
+            segment_0.q4d_1 = segment_0.r4d_1;
+            buffer.w4c_1 = segment_0.q4d_1;
           } else {
-            ensureNotNull(ensureNotNull(buffer.d4d_1).y4d_1).d4e(segment_0);
+            ensureNotNull(ensureNotNull(buffer.w4c_1).r4d_1).w4d(segment_0);
           }
           pos = pos + byteCount_0 | 0;
           s = s + 1 | 0;
         }
         var tmp = buffer;
         // Inline function 'kotlin.Long.plus' call
-        var this_0 = buffer.e4d_1;
-        tmp.e4d_1 = add(this_0, fromInt(byteCount));
+        var this_0 = buffer.x4c_1;
+        tmp.x4c_1 = add(this_0, fromInt(byteCount));
         return Unit_instance;
       }
-      b4g(offset, other, otherOffset, byteCount) {
+      u4f(offset, other, otherOffset, byteCount) {
         var tmp$ret$0;
         $l$block_0: {
           // Inline function 'okio.internal.commonRangeEquals' call
@@ -122,15 +122,15 @@ function SegmentedByteString() {
           var s = segment(this, offset);
           var pos = offset;
           while (pos < endIndex) {
-            var segmentOffset = s === 0 ? 0 : this.b4f_1[s - 1 | 0];
-            var segmentSize = this.b4f_1[s] - segmentOffset | 0;
-            var segmentPos = this.b4f_1[this.a4f_1.length + s | 0];
+            var segmentOffset = s === 0 ? 0 : this.u4e_1[s - 1 | 0];
+            var segmentSize = this.u4e_1[s] - segmentOffset | 0;
+            var segmentPos = this.u4e_1[this.t4e_1.length + s | 0];
             // Inline function 'kotlin.comparisons.minOf' call
             var b = segmentOffset + segmentSize | 0;
             var byteCount_0 = Math.min(endIndex, b) - pos | 0;
             var offset_0 = segmentPos + (pos - segmentOffset | 0) | 0;
-            var data = this.a4f_1[s];
-            if (!other.c4g(otherOffset_0, data, offset_0, byteCount_0)) {
+            var data = this.t4e_1[s];
+            if (!other.v4f(otherOffset_0, data, offset_0, byteCount_0)) {
               tmp$ret$0 = false;
               break $l$block_0;
             }
@@ -142,7 +142,7 @@ function SegmentedByteString() {
         }
         return tmp$ret$0;
       }
-      c4g(offset, other, otherOffset, byteCount) {
+      v4f(offset, other, otherOffset, byteCount) {
         var tmp$ret$0;
         $l$block_0: {
           // Inline function 'okio.internal.commonRangeEquals' call
@@ -155,14 +155,14 @@ function SegmentedByteString() {
           var s = segment(this, offset);
           var pos = offset;
           while (pos < endIndex) {
-            var segmentOffset = s === 0 ? 0 : this.b4f_1[s - 1 | 0];
-            var segmentSize = this.b4f_1[s] - segmentOffset | 0;
-            var segmentPos = this.b4f_1[this.a4f_1.length + s | 0];
+            var segmentOffset = s === 0 ? 0 : this.u4e_1[s - 1 | 0];
+            var segmentSize = this.u4e_1[s] - segmentOffset | 0;
+            var segmentPos = this.u4e_1[this.t4e_1.length + s | 0];
             // Inline function 'kotlin.comparisons.minOf' call
             var b = segmentOffset + segmentSize | 0;
             var byteCount_0 = Math.min(endIndex, b) - pos | 0;
             var offset_0 = segmentPos + (pos - segmentOffset | 0) | 0;
-            var data = this.a4f_1[s];
+            var data = this.t4e_1[s];
             if (!arrayRangeEquals(data, offset_0, other, otherOffset_0, byteCount_0)) {
               tmp$ret$0 = false;
               break $l$block_0;
@@ -175,8 +175,8 @@ function SegmentedByteString() {
         }
         return tmp$ret$0;
       }
-      p4e() {
-        return this.z4f();
+      i4e() {
+        return this.s4f();
       }
       equals(other) {
         // Inline function 'okio.internal.commonEquals' call
@@ -185,7 +185,7 @@ function SegmentedByteString() {
           tmp = true;
         } else {
           if (other instanceof ByteString()) {
-            tmp = (other.q2() === this.q2() && this.b4g(0, other, 0, this.q2()));
+            tmp = (other.q2() === this.q2() && this.u4f(0, other, 0, this.q2()));
           } else {
             tmp = false;
           }
@@ -196,20 +196,20 @@ function SegmentedByteString() {
         var tmp$ret$0;
         $l$block: {
           // Inline function 'okio.internal.commonHashCode' call
-          var result = this.g4d_1;
+          var result = this.z4c_1;
           if (!(result === 0)) {
             tmp$ret$0 = result;
             break $l$block;
           }
           result = 1;
           // Inline function 'okio.internal.forEachSegment' call
-          var segmentCount = this.a4f_1.length;
+          var segmentCount = this.t4e_1.length;
           var s = 0;
           var pos = 0;
           while (s < segmentCount) {
-            var segmentPos = this.b4f_1[segmentCount + s | 0];
-            var nextSegmentOffset = this.b4f_1[s];
-            var tmp0 = this.a4f_1[s];
+            var segmentPos = this.u4e_1[segmentCount + s | 0];
+            var nextSegmentOffset = this.u4e_1[s];
+            var tmp0 = this.t4e_1[s];
             var i = segmentPos;
             var limit = segmentPos + (nextSegmentOffset - pos | 0) | 0;
             while (i < limit) {
@@ -219,7 +219,7 @@ function SegmentedByteString() {
             pos = nextSegmentOffset;
             s = s + 1 | 0;
           }
-          this.u4f(result);
+          this.n4f(result);
           tmp$ret$0 = result;
         }
         return tmp$ret$0;

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

@@ -38,7 +38,7 @@ function arrayRangeEquals(a, aOffset, b, bOffset, byteCount) {
 function checkOffsetAndCount(size, offset, byteCount) {
   _init_properties_Util_kt__laey5a();
   if (compare(bitwiseOr(offset, byteCount), new (Long())(0, 0)) < 0 || compare(offset, size) > 0 || compare(subtract(size, offset), byteCount) < 0) {
-    throw ArrayIndexOutOfBoundsException().o4e('size=' + size.toString() + ' offset=' + offset.toString() + ' byteCount=' + byteCount.toString());
+    throw ArrayIndexOutOfBoundsException().h4e('size=' + size.toString() + ' offset=' + offset.toString() + ' byteCount=' + byteCount.toString());
   }
 }
 var properties_initialized_Util_kt_13atj0;

package/kotlin/okio-parent-okio/okio/internal/-Utf8.mjs

@@ -140,7 +140,7 @@ function commonToUtf8String(_this__u8e3s4, beginIndex, endIndex) {
   beginIndex = beginIndex === VOID ? 0 : beginIndex;
   endIndex = endIndex === VOID ? _this__u8e3s4.length : endIndex;
   if (beginIndex < 0 || endIndex > _this__u8e3s4.length || beginIndex > endIndex) {
-    throw ArrayIndexOutOfBoundsException().o4e('size=' + _this__u8e3s4.length + ' beginIndex=' + beginIndex + ' endIndex=' + endIndex);
+    throw ArrayIndexOutOfBoundsException().h4e('size=' + _this__u8e3s4.length + ' beginIndex=' + beginIndex + ' endIndex=' + endIndex);
   }
   var chars = charArray(endIndex - beginIndex | 0);
   var length = 0;

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

@@ -51,14 +51,14 @@ function commonIndexOf(_this__u8e3s4, bytes, fromIndex, toIndex, bytesOffset, by
   }
   var fromIndex_0 = fromIndex;
   var toIndex_0 = toIndex;
-  if (compare(toIndex_0, _this__u8e3s4.e4d_1) > 0)
-    toIndex_0 = _this__u8e3s4.e4d_1;
+  if (compare(toIndex_0, _this__u8e3s4.x4c_1) > 0)
+    toIndex_0 = _this__u8e3s4.x4c_1;
   if (equalsLong(fromIndex_0, toIndex_0))
     return new (Long())(-1, -1);
   var tmp2 = fromIndex_0;
   $l$block_1: {
     // Inline function 'okio.internal.seek' call
-    var tmp0_elvis_lhs = _this__u8e3s4.d4d_1;
+    var tmp0_elvis_lhs = _this__u8e3s4.w4c_1;
     var tmp;
     if (tmp0_elvis_lhs == null) {
       var offset = new (Long())(-1, -1);
@@ -70,48 +70,48 @@ function commonIndexOf(_this__u8e3s4, bytes, fromIndex, toIndex, bytesOffset, by
       }
       var s = tmp_0;
       var offset_0 = offset;
-      var targetByteArray = bytes.p4e();
+      var targetByteArray = bytes.i4e();
       var b0 = targetByteArray[bytesOffset];
       var tmp0 = toIndex_0;
       // Inline function 'kotlin.Long.minus' call
-      var this_0 = _this__u8e3s4.e4d_1;
+      var this_0 = _this__u8e3s4.x4c_1;
       var tmp$ret$8 = subtract(this_0, fromInt(byteCount));
       // Inline function 'kotlin.comparisons.minOf' call
       var b = add(tmp$ret$8, new (Long())(1, 0));
       var resultLimit = compare(tmp0, b) <= 0 ? tmp0 : b;
       while (compare(offset_0, resultLimit) < 0) {
-        var data = s.s4d_1;
-        var tmp0_0 = s.u4d_1;
+        var data = s.l4d_1;
+        var tmp0_0 = s.n4d_1;
         // Inline function 'okio.minOf' call
-        var b_0 = subtract(add(numberToLong(s.t4d_1), resultLimit), offset_0);
+        var b_0 = subtract(add(numberToLong(s.m4d_1), resultLimit), offset_0);
         // Inline function 'kotlin.comparisons.minOf' call
         var a = fromInt(tmp0_0);
         var tmp$ret$10 = compare(a, b_0) <= 0 ? a : b_0;
         var segmentLimit = convertToInt(tmp$ret$10);
-        var inductionVariable = convertToInt(subtract(add(numberToLong(s.t4d_1), fromIndex_0), offset_0));
+        var inductionVariable = convertToInt(subtract(add(numberToLong(s.m4d_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, bytesOffset + 1 | 0, byteCount)) {
-              return add(numberToLong(pos - s.t4d_1 | 0), offset_0);
+              return add(numberToLong(pos - s.m4d_1 | 0), offset_0);
             }
           }
            while (inductionVariable < segmentLimit);
-        offset_0 = add(offset_0, fromInt(s.u4d_1 - s.t4d_1 | 0));
+        offset_0 = add(offset_0, fromInt(s.n4d_1 - s.m4d_1 | 0));
         fromIndex_0 = offset_0;
-        s = ensureNotNull(s.x4d_1);
+        s = ensureNotNull(s.q4d_1);
       }
       return new (Long())(-1, -1);
     } else {
       tmp = tmp0_elvis_lhs;
     }
     var s_0 = tmp;
-    if (compare(subtract(_this__u8e3s4.e4d_1, tmp2), tmp2) < 0) {
-      var offset_1 = _this__u8e3s4.e4d_1;
+    if (compare(subtract(_this__u8e3s4.x4c_1, tmp2), tmp2) < 0) {
+      var offset_1 = _this__u8e3s4.x4c_1;
       while (compare(offset_1, tmp2) > 0) {
-        s_0 = ensureNotNull(s_0.y4d_1);
-        offset_1 = subtract(offset_1, fromInt(s_0.u4d_1 - s_0.t4d_1 | 0));
+        s_0 = ensureNotNull(s_0.r4d_1);
+        offset_1 = subtract(offset_1, fromInt(s_0.n4d_1 - s_0.m4d_1 | 0));
       }
       var tmp0_1 = s_0;
       var offset_2 = offset_1;
@@ -123,37 +123,37 @@ function commonIndexOf(_this__u8e3s4, bytes, fromIndex, toIndex, bytesOffset, by
       }
       var s_1 = tmp_1;
       var offset_3 = offset_2;
-      var targetByteArray_0 = bytes.p4e();
+      var targetByteArray_0 = bytes.i4e();
       var b0_0 = targetByteArray_0[bytesOffset];
       var tmp0_2 = toIndex_0;
       // Inline function 'kotlin.Long.minus' call
-      var this_1 = _this__u8e3s4.e4d_1;
+      var this_1 = _this__u8e3s4.x4c_1;
       var tmp$ret$13 = subtract(this_1, fromInt(byteCount));
       // Inline function 'kotlin.comparisons.minOf' call
       var b_1 = add(tmp$ret$13, new (Long())(1, 0));
       var resultLimit_0 = compare(tmp0_2, b_1) <= 0 ? tmp0_2 : b_1;
       while (compare(offset_3, resultLimit_0) < 0) {
-        var data_0 = s_1.s4d_1;
-        var tmp0_3 = s_1.u4d_1;
+        var data_0 = s_1.l4d_1;
+        var tmp0_3 = s_1.n4d_1;
         // Inline function 'okio.minOf' call
-        var b_2 = subtract(add(numberToLong(s_1.t4d_1), resultLimit_0), offset_3);
+        var b_2 = subtract(add(numberToLong(s_1.m4d_1), resultLimit_0), offset_3);
         // Inline function 'kotlin.comparisons.minOf' call
         var a_0 = fromInt(tmp0_3);
         var tmp$ret$15 = compare(a_0, b_2) <= 0 ? a_0 : b_2;
         var segmentLimit_0 = convertToInt(tmp$ret$15);
-        var inductionVariable_0 = convertToInt(subtract(add(numberToLong(s_1.t4d_1), fromIndex_0), offset_3));
+        var inductionVariable_0 = convertToInt(subtract(add(numberToLong(s_1.m4d_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, bytesOffset + 1 | 0, byteCount)) {
-              return add(numberToLong(pos_0 - s_1.t4d_1 | 0), offset_3);
+              return add(numberToLong(pos_0 - s_1.m4d_1 | 0), offset_3);
             }
           }
            while (inductionVariable_0 < segmentLimit_0);
-        offset_3 = add(offset_3, fromInt(s_1.u4d_1 - s_1.t4d_1 | 0));
+        offset_3 = add(offset_3, fromInt(s_1.n4d_1 - s_1.m4d_1 | 0));
         fromIndex_0 = offset_3;
-        s_1 = ensureNotNull(s_1.x4d_1);
+        s_1 = ensureNotNull(s_1.q4d_1);
       }
       return new (Long())(-1, -1);
     } else {
@@ -161,11 +161,11 @@ function commonIndexOf(_this__u8e3s4, bytes, fromIndex, toIndex, bytesOffset, by
       $l$loop: while (true) {
         var tmp0_4 = offset_4;
         // Inline function 'kotlin.Long.plus' call
-        var other = s_0.u4d_1 - s_0.t4d_1 | 0;
+        var other = s_0.n4d_1 - s_0.m4d_1 | 0;
         var nextOffset = add(tmp0_4, fromInt(other));
         if (compare(nextOffset, tmp2) > 0)
           break $l$loop;
-        s_0 = ensureNotNull(s_0.x4d_1);
+        s_0 = ensureNotNull(s_0.q4d_1);
         offset_4 = nextOffset;
       }
       var tmp0_5 = s_0;
@@ -178,37 +178,37 @@ function commonIndexOf(_this__u8e3s4, bytes, fromIndex, toIndex, bytesOffset, by
       }
       var s_2 = tmp_2;
       var offset_6 = offset_5;
-      var targetByteArray_1 = bytes.p4e();
+      var targetByteArray_1 = bytes.i4e();
       var b0_1 = targetByteArray_1[bytesOffset];
       var tmp0_6 = toIndex_0;
       // Inline function 'kotlin.Long.minus' call
-      var this_2 = _this__u8e3s4.e4d_1;
+      var this_2 = _this__u8e3s4.x4c_1;
       var tmp$ret$19 = subtract(this_2, fromInt(byteCount));
       // Inline function 'kotlin.comparisons.minOf' call
       var b_3 = add(tmp$ret$19, new (Long())(1, 0));
       var resultLimit_1 = compare(tmp0_6, b_3) <= 0 ? tmp0_6 : b_3;
       while (compare(offset_6, resultLimit_1) < 0) {
-        var data_1 = s_2.s4d_1;
-        var tmp0_7 = s_2.u4d_1;
+        var data_1 = s_2.l4d_1;
+        var tmp0_7 = s_2.n4d_1;
         // Inline function 'okio.minOf' call
-        var b_4 = subtract(add(numberToLong(s_2.t4d_1), resultLimit_1), offset_6);
+        var b_4 = subtract(add(numberToLong(s_2.m4d_1), resultLimit_1), offset_6);
         // Inline function 'kotlin.comparisons.minOf' call
         var a_1 = fromInt(tmp0_7);
         var tmp$ret$21 = compare(a_1, b_4) <= 0 ? a_1 : b_4;
         var segmentLimit_1 = convertToInt(tmp$ret$21);
-        var inductionVariable_1 = convertToInt(subtract(add(numberToLong(s_2.t4d_1), fromIndex_0), offset_6));
+        var inductionVariable_1 = convertToInt(subtract(add(numberToLong(s_2.m4d_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, bytesOffset + 1 | 0, byteCount)) {
-              return add(numberToLong(pos_1 - s_2.t4d_1 | 0), offset_6);
+              return add(numberToLong(pos_1 - s_2.m4d_1 | 0), offset_6);
             }
           }
            while (inductionVariable_1 < segmentLimit_1);
-        offset_6 = add(offset_6, fromInt(s_2.u4d_1 - s_2.t4d_1 | 0));
+        offset_6 = add(offset_6, fromInt(s_2.n4d_1 - s_2.m4d_1 | 0));
         fromIndex_0 = offset_6;
-        s_2 = ensureNotNull(s_2.x4d_1);
+        s_2 = ensureNotNull(s_2.q4d_1);
       }
       return new (Long())(-1, -1);
     }
@@ -230,11 +230,11 @@ function readUtf8Line(_this__u8e3s4, newline) {
     tmp_0 = false;
   }
   if (tmp_0) {
-    var result = _this__u8e3s4.q4e(subtract(newline, new (Long())(1, 0)));
+    var result = _this__u8e3s4.j4e(subtract(newline, new (Long())(1, 0)));
     _this__u8e3s4.f1q(new (Long())(2, 0));
     tmp = result;
   } else {
-    var result_0 = _this__u8e3s4.q4e(newline);
+    var result_0 = _this__u8e3s4.j4e(newline);
     _this__u8e3s4.f1q(new (Long())(1, 0));
     tmp = result_0;
   }
@@ -243,7 +243,7 @@ function readUtf8Line(_this__u8e3s4, newline) {
 function selectPrefix(_this__u8e3s4, options, selectTruncated) {
   selectTruncated = selectTruncated === VOID ? false : selectTruncated;
   _init_properties_Buffer_kt__ndcom8();
-  var tmp0_elvis_lhs = _this__u8e3s4.d4d_1;
+  var tmp0_elvis_lhs = _this__u8e3s4.w4c_1;
   var tmp;
   if (tmp0_elvis_lhs == null) {
     return selectTruncated ? -2 : -1;
@@ -252,10 +252,10 @@ function selectPrefix(_this__u8e3s4, options, selectTruncated) {
   }
   var head = tmp;
   var s = head;
-  var data = head.s4d_1;
-  var pos = head.t4d_1;
-  var limit = head.u4d_1;
-  var trie = options.m4d_1;
+  var data = head.l4d_1;
+  var pos = head.m4d_1;
+  var limit = head.n4d_1;
+  var trie = options.f4d_1;
   var triePos = 0;
   var prefixIndex = -1;
   navigateTrie: while (true) {
@@ -286,10 +286,10 @@ function selectPrefix(_this__u8e3s4, options, selectTruncated) {
           return prefixIndex;
         var scanComplete = triePos === trieLimit;
         if (pos === limit) {
-          s = ensureNotNull(ensureNotNull(s).x4d_1);
-          pos = s.t4d_1;
-          data = s.s4d_1;
-          limit = s.u4d_1;
+          s = ensureNotNull(ensureNotNull(s).q4d_1);
+          pos = s.m4d_1;
+          data = s.l4d_1;
+          limit = s.n4d_1;
           if (s === head) {
             if (!scanComplete)
               break navigateTrie;
@@ -319,10 +319,10 @@ function selectPrefix(_this__u8e3s4, options, selectTruncated) {
         triePos = triePos + 1 | 0;
       }
       if (pos === limit) {
-        s = ensureNotNull(s.x4d_1);
-        pos = s.t4d_1;
-        data = s.s4d_1;
-        limit = s.u4d_1;
+        s = ensureNotNull(s.q4d_1);
+        pos = s.m4d_1;
+        data = s.l4d_1;
+        limit = s.n4d_1;
         if (s === head) {
           s = null;
         }
@@ -340,15 +340,15 @@ function rangeEquals(segment, segmentPos, bytes, bytesOffset, bytesLimit) {
   _init_properties_Buffer_kt__ndcom8();
   var segment_0 = segment;
   var segmentPos_0 = segmentPos;
-  var segmentLimit = segment_0.u4d_1;
-  var data = segment_0.s4d_1;
+  var segmentLimit = segment_0.n4d_1;
+  var data = segment_0.l4d_1;
   var i = bytesOffset;
   while (i < bytesLimit) {
     if (segmentPos_0 === segmentLimit) {
-      segment_0 = ensureNotNull(segment_0.x4d_1);
-      data = segment_0.s4d_1;
-      segmentPos_0 = segment_0.t4d_1;
-      segmentLimit = segment_0.u4d_1;
+      segment_0 = ensureNotNull(segment_0.q4d_1);
+      data = segment_0.l4d_1;
+      segmentPos_0 = segment_0.m4d_1;
+      segmentLimit = segment_0.n4d_1;
     }
     if (!(data[segmentPos_0] === bytes[i])) {
       return false;

package/kotlin/okio-parent-okio/okio/internal/ByteString.mjs

@@ -15,7 +15,7 @@ function get_HEX_DIGIT_CHARS() {
 var HEX_DIGIT_CHARS;
 function commonWrite(_this__u8e3s4, buffer, offset, byteCount) {
   _init_properties_ByteString_kt__sqjq7b();
-  buffer.r4e(_this__u8e3s4.f4d_1, offset, byteCount);
+  buffer.k4e(_this__u8e3s4.y4c_1, offset, byteCount);
 }
 function codePointIndexToCharIndex(s, codePointCount) {
   _init_properties_ByteString_kt__sqjq7b();

package/kotlin/okio-parent-okio/okio/internal/RealBufferedSource.mjs

@@ -24,25 +24,25 @@ function commonIndexOf_0(_this__u8e3s4, bytes, bytesOffset, byteCount, fromIndex
   checkOffsetAndCount(fromInt(bytes.q2()), fromInt(bytesOffset), fromInt(byteCount));
   var fromIndex_0 = fromIndex;
   // Inline function 'kotlin.check' call
-  if (!!_this__u8e3s4.t4e_1) {
+  if (!!_this__u8e3s4.m4e_1) {
     var message = 'closed';
     throw IllegalStateException().o(toString(message));
   }
   while (true) {
-    var result = commonIndexOf(_this__u8e3s4.u4e_1, bytes, fromIndex_0, toIndex, bytesOffset, byteCount);
+    var result = commonIndexOf(_this__u8e3s4.n4e_1, bytes, fromIndex_0, toIndex, bytesOffset, byteCount);
     if (!equalsLong(result, new (Long())(-1, -1)))
       return result;
-    var lastBufferSize = _this__u8e3s4.u4e_1.e4d_1;
+    var lastBufferSize = _this__u8e3s4.n4e_1.x4c_1;
     // Inline function 'kotlin.Long.minus' call
     // Inline function 'kotlin.Long.plus' call
     var this_0 = subtract(lastBufferSize, fromInt(byteCount));
     var nextFromIndex = add(this_0, fromInt(1));
     if (compare(nextFromIndex, toIndex) >= 0)
       return new (Long())(-1, -1);
-    if (!isMatchPossibleByExpandingBuffer(_this__u8e3s4.u4e_1, bytes, bytesOffset, byteCount, fromIndex_0, toIndex)) {
+    if (!isMatchPossibleByExpandingBuffer(_this__u8e3s4.n4e_1, bytes, bytesOffset, byteCount, fromIndex_0, toIndex)) {
       return new (Long())(-1, -1);
     }
-    if (equalsLong(_this__u8e3s4.s4e_1.v4e(_this__u8e3s4.u4e_1, new (Long())(8192, 0)), new (Long())(-1, -1)))
+    if (equalsLong(_this__u8e3s4.l4e_1.o4e(_this__u8e3s4.n4e_1, new (Long())(8192, 0)), new (Long())(-1, -1)))
       return new (Long())(-1, -1);
     // Inline function 'kotlin.comparisons.maxOf' call
     var a = fromIndex_0;
@@ -50,17 +50,17 @@ function commonIndexOf_0(_this__u8e3s4, bytes, bytesOffset, byteCount, fromIndex
   }
 }
 function isMatchPossibleByExpandingBuffer(_this__u8e3s4, bytes, bytesOffset, byteCount, fromIndex, toIndex) {
-  if (compare(_this__u8e3s4.e4d_1, toIndex) < 0)
+  if (compare(_this__u8e3s4.x4c_1, toIndex) < 0)
     return true;
   var tmp0 = new (Long())(1, 0);
   // Inline function 'kotlin.Long.plus' call
-  var this_0 = subtract(_this__u8e3s4.e4d_1, toIndex);
+  var this_0 = subtract(_this__u8e3s4.x4c_1, toIndex);
   // Inline function 'kotlin.comparisons.maxOf' call
   var b = add(this_0, fromInt(1));
   var tmp$ret$1 = compare(tmp0, b) >= 0 ? tmp0 : b;
   var begin = convertToInt(tmp$ret$1);
   // Inline function 'kotlin.Long.plus' call
-  var this_1 = subtract(_this__u8e3s4.e4d_1, fromIndex);
+  var this_1 = subtract(_this__u8e3s4.x4c_1, fromIndex);
   // Inline function 'okio.minOf' call
   var b_0 = add(this_1, fromInt(1));
   // Inline function 'kotlin.comparisons.minOf' call
@@ -72,11 +72,11 @@ function isMatchPossibleByExpandingBuffer(_this__u8e3s4, bytes, bytesOffset, byt
     do {
       var i = inductionVariable;
       inductionVariable = inductionVariable + -1 | 0;
-      var tmp0_0 = _this__u8e3s4.e4d_1;
+      var tmp0_0 = _this__u8e3s4.x4c_1;
       // Inline function 'kotlin.Long.minus' call
       var other = i;
       var tmp$ret$5 = subtract(tmp0_0, fromInt(other));
-      if (_this__u8e3s4.w4e(tmp$ret$5, bytes, bytesOffset, i)) {
+      if (_this__u8e3s4.p4e(tmp$ret$5, bytes, bytesOffset, i)) {
         return true;
       }
     }

package/kotlin/okio-parent-okio/okio/internal/SegmentedByteString.mjs

@@ -1,7 +1,7 @@
 //region block: pre-declaration
 //endregion
 function segment(_this__u8e3s4, pos) {
-  var i = binarySearch(_this__u8e3s4.b4f_1, pos + 1 | 0, 0, _this__u8e3s4.a4f_1.length);
+  var i = binarySearch(_this__u8e3s4.u4e_1, pos + 1 | 0, 0, _this__u8e3s4.t4e_1.length);
   return i >= 0 ? i : ~i;
 }
 function binarySearch(_this__u8e3s4, value, fromIndex, toIndex) {